What does the Interlocked class do, and how do you build a lock-free update with CompareExchange?

1. What the hardware does

On older Arm64 without LSE, the runtime uses load-exclusive/store-exclusive loops (ldaxr/stlxr). All Interlocked operations act as full fences: no reads or writes move across them in either direction.

The lock prefix makes the core hold the cache line exclusively for the read-modify-write. That's why contended atomics are expensive: the line must travel between cores' caches.

2. Swapping immutable state (multi-field invariants)

public sealed record Stats(long Count, int Max, DateTime Last);

private Stats _stats = new(0, 0, DateTime.MinValue);

public void Record(int latency)
{
    Stats current, next;
    do
    {
        current = Volatile.Read(ref _stats);
        next = current with
        {
            Count = current.Count + 1,
            Max = Math.Max(current.Max, latency),
            Last = DateTime.UtcNow,
        };
    }
    while (Interlocked.CompareExchange(ref _stats, next, current) != current);
}

Readers always see a consistent Stats object. The cost is one allocation per update and retries under contention, so for very hot paths a lock may actually be faster. Measure.

3. Lazy, thread-safe initialisation

private ExpensiveClient? _client;

public ExpensiveClient Client
{
    get
    {
        var c = Volatile.Read(ref _client);
        if (c is not null) return c;
        var created = new ExpensiveClient();
        var winner = Interlocked.CompareExchange(ref _client, created, null) ?? created;
        if (!ReferenceEquals(winner, created)) created.Dispose();   // lost the race
        return winner;
    }
}

This may construct more than one instance under a race (losers are disposed). If construction must happen exactly once, use Lazy<T> (ExecutionAndPublication) or LazyInitializer.EnsureInitialized with a lock object.

4. ABA, concretely

A lock-free stack using a pooled node: thread 1 reads head = A (next = B), gets preempted; thread 2 pops A, pops B, pushes A back (reused). Thread 1's CAS(head, B, A) succeeds, setting head to B, a node no longer in the stack. In .NET, allocating new nodes and letting the GC reclaim them avoids this for references, because A can't be reused while thread 1 still references it. Pooling nodes or using integer indices brings ABA back; version counters (tagged values) fix it.

5. Contention and striping

1 counter, 32 cores incrementing:   throughput limited by cache-line transfers
32 padded counters (one per core):  near-linear scaling; sum on read (slightly stale but consistent enough)

System.Diagnostics.Metrics instruments and many BCL counters already use this kind of aggregation.

6. Version notes

7. Try it yourself

1. Run the code example; then replace Interlocked.Increment with _count++ and compare totals.
2. Write a CAS loop that doesn't re-read inside the loop and observe incorrect results under contention.
3. Benchmark one shared counter vs 8 padded per-thread counters with 8 threads.
4. Implement the immutable Stats swap and compare throughput with a lock version.
5. Use Interlocked.Exchange(ref _buffer, null) to take ownership of a buffer exactly once across threads.
6. Look at the generated assembly in SharpLab (JIT Asm view) for Interlocked.Increment.

using System.Threading;

var stats = new RequestStats();
await Task.WhenAll(Enumerable.Range(0, 8).Select(i => Task.Run(() =>
{
    var rnd = new Random(i);
    for (int n = 0; n < 100_000; n++) stats.Record(rnd.Next(1, 1000));
})));
Console.WriteLine($"Count {stats.Count}, max latency {stats.MaxLatency}");

var once = new OnceFlag();
int winners = 0;
Parallel.For(0, 100, _ => { if (once.TryClaim()) Interlocked.Increment(ref winners); });
Console.WriteLine($"Winners: {winners}"); // 1

public sealed class RequestStats
{
    private long _count;
    private int _maxLatency;

    public long Count => Interlocked.Read(ref _count);
    public int MaxLatency => Volatile.Read(ref _maxLatency);

    public void Record(int latencyMs)
    {
        Interlocked.Increment(ref _count);

        int current;
        do
        {
            current = Volatile.Read(ref _maxLatency);
            if (latencyMs <= current) return;
        }
        while (Interlocked.CompareExchange(ref _maxLatency, latencyMs, current) != current);
    }
}

public sealed class OnceFlag
{
    private int _claimed;
    public bool TryClaim() => Interlocked.CompareExchange(ref _claimed, 1, 0) == 0;
}