Parallelism and Thread Safety

A race occurs when correctness depends on unpredictable interleaving. Even simple read-modify-write operations are not automatically atomic. Memory visibility also matters: one thread must reliably observe another thread’s writes.

Advanced C# work improves when you separate language syntax, runtime behavior, and application policy. Write down which layer owns the guarantee in this lesson. Then identify the observable evidence—a compiler rejection, test result, generated query, trace, or measurement—that would prove the model correct.

lock provides mutual exclusion around a synchronous critical section. Interlocked handles a narrow set of atomic operations. SemaphoreSlim bounds concurrency, while concurrent collections coordinate common data structures. Never await while holding a monitor lock.

The starter isolates one part of the mental model so it can run in the browser. The exercise moves the same rule into a current local .NET project where packages, framework hosting, diagnostics, and multi-file tests are available.

using System;
using System.Threading;

class Program
{
  static int counter;

  static void Main()
  {
      for (int i = 0; i < 1000; i++) Interlocked.Increment(ref counter);
      Console.WriteLine(counter);
  }
}

1000

Locking different resources in inconsistent order can deadlock. A thread-safe collection does not make a multi-step business invariant atomic. Parallel.ForEach can slow small workloads through scheduling overhead and contention.

Classify each failure as a contract violation, transient operational failure, permanent dependency response, concurrency conflict, or programmer defect. That classification determines whether to reject, retry, compensate, cancel, or fail fast. A generic catch-and-continue policy destroys the information needed to make that decision.

Write a sequential correct baseline, measure representative CPU work, and introduce parallelism only where throughput benefits. Load tests should assert results, not merely absence of exceptions, because races often return plausible wrong totals.

Finish by making the result operable. Add structured diagnostics at the boundary, propagate cancellation, avoid sensitive data, and record SDK and dependency versions. Test the public behavior instead of private implementation details. If a framework or provider performs translation, serialization, concurrency, or I/O, include at least one test against the real production technology.

A senior-level review should be able to answer four questions: what contract is promised, who owns lifetime and cleanup, how failures become visible, and what evidence supports the design. If any answer depends on “the framework probably handles it,” inspect the documentation or runtime behavior and turn the assumption into a checked decision.