📝 Lesson 2.2: Thread Safety and Synchronization

The Race Condition

Threads share memory (Lesson 2.1). When two threads modify the same variable without coordination, the result depends on unpredictable timing — a race condition. The classic example is a shared counter:

int count = 0;

// 4 tasks each incrementing 1,000,000 times → we expect 4,000,000
Task[] tasks = Enumerable.Range(0, 4)
    .Select(_ => Task.Run(() =>
    {
        for (int i = 0; i < 1_000_000; i++)
        {
            count++;          // ❌ NOT thread-safe
        }
    }))
    .ToArray();

await Task.WhenAll(tasks);
Console.WriteLine(count);     // ⚠️ Some number LESS than 4,000,000 — and different each run

The lock Statement

The simplest fix is lock. It ensures only one thread at a time can enter the guarded block; others wait their turn. You lock on a private reference-type object dedicated to that purpose:

private static readonly object _gate = new object();
private static int _count = 0;

void Increment()
{
    lock (_gate)          // only one thread inside at a time
    {
        _count++;         // now safe — read/add/write can't be interleaved
    }
}

Applied to the counter example, the total is now exactly 4,000,000 every run, because the increments can no longer interleave.

Interlocked (Lock-Free)

For simple numeric operations, taking a lock is heavier than needed. The Interlocked class performs atomic operations directly — a single, uninterruptible CPU instruction — with no lock overhead:

using System.Threading;

long _count = 0;

void Increment()
{
    Interlocked.Increment(ref _count);   // atomic ++ — thread-safe, lock-free
}

Common atomic operations:

Concurrent Collections

Standard collections like List<T> and Dictionary<TKey,TValue> are not thread-safe — concurrent writes can corrupt them or throw. Rather than wrapping every access in a lock, use the purpose-built types in System.Collections.Concurrent:

using System.Collections.Concurrent;

var wordCounts = new ConcurrentDictionary<string, int>();

Parallel.ForEach(words, word =>
{
    // Atomically add or increment — no explicit lock needed
    wordCounts.AddOrUpdate(word, 1, (key, existing) => existing + 1);
});

Deadlocks

Locks solve races but introduce a new hazard. A deadlock is when two threads each hold a lock the other needs, so both wait forever:

// Thread 1: lock A, then B     Thread 2: lock B, then A
lock (_lockA)                    lock (_lockB)
{                                {
    lock (_lockB)                    lock (_lockA)
    {                                {
        // ...                            // ...
    }                                }
}                                }
// If timed just wrong: T1 holds A waiting for B, T2 holds B waiting for A → frozen.

Immutability as a Strategy

The safest shared data is data that can't change. If a value is immutable, threads can read it freely with zero synchronization — there's no write to race against. This is a major reason immutable types matter in concurrent code.

// A record is immutable by default (Intermediate 3.1) — safe to share across threads
public record Config(string Host, int Port, bool UseTls);

// To "change" it, create a new copy (with-expression) — the original is untouched
Config updated = current with { Port = 8080 };

Exercise & Quiz

int count = 0;
var tasks = Enumerable.Range(0, 4).Select(_ => Task.Run(() =>
{
    for (int i = 0; i < 1_000_000; i++) count++;   // race!
})).ToArray();
await Task.WhenAll(tasks);
Console.WriteLine($"Broken total: {count}");   // usually < 4,000,000

// TODO: Fix A (lock), Fix B (Interlocked)

using System.Threading;

// Fix A: lock
int countA = 0;
object gate = new();
await Task.WhenAll(Enumerable.Range(0, 4).Select(_ => Task.Run(() =>
{
    for (int i = 0; i < 1_000_000; i++)
    {
        lock (gate) { countA++; }
    }
})));
Console.WriteLine($"lock total: {countA}");        // 4000000

// Fix B: Interlocked
long countB = 0;
await Task.WhenAll(Enumerable.Range(0, 4).Select(_ => Task.Run(() =>
{
    for (int i = 0; i < 1_000_000; i++)
    {
        Interlocked.Increment(ref countB);
    }
})));
Console.WriteLine($"Interlocked total: {countB}"); // 4000000

Summary

📚 Additional Resources

• The lock statement — reference
• Interlocked — API reference
• Thread-safe collections — .NET

🚀 What's Next?

You can now make shared data safe. Next, we scale computation across cores with less manual work. In Lesson 2.3: Data Parallelism, you'll use Parallel and PLINQ to process large datasets in parallel.