What are memory barriers, why do CPUs and compilers reorder memory operations, and how does .NET expose barriers?

1. Store buffers, concretely

Core 0                       Core 1
_flagA = 1  -> store buffer  _flagB = 1  -> store buffer
r0 = _flagB (from cache: 0)  r1 = _flagA (from cache: 0)
store buffers drain later    -> both r0 == 0 and r1 == 0 observed

Even x64, which keeps loads in order and stores in order, allows this one reordering. A full fence (lock-prefixed instruction / mfence, or dmb ish on Arm64) drains the store buffer before the load.

2. Publication with acquire/release (SPSC ring buffer)

public sealed class SpscRing<T>(int capacity)
{
    private readonly T[] _items = new T[capacity];
    private int _head;   // consumer-owned
    private int _tail;   // producer-owned

    public bool TryEnqueue(T item)
    {
        int tail = _tail;
        int next = (tail + 1) % _items.Length;
        if (next == Volatile.Read(ref _head)) return false;   // full (acquire: see consumer's progress)
        _items[tail] = item;                                   // write data
        Volatile.Write(ref _tail, next);                       // release: data visible before new tail
        return true;
    }

    public bool TryDequeue(out T item)
    {
        int head = _head;
        if (head == Volatile.Read(ref _tail)) { item = default!; return false; }   // acquire
        item = _items[head];
        _items[head] = default!;
        Volatile.Write(ref _head, (head + 1) % _items.Length);  // release slot back to producer
        return true;
    }
}

This is correct only for one producer and one consumer. That restriction is exactly why Channel<T> with SingleReader/SingleWriter is usually the better choice.

3. Cost of fences

MemoryBarrierProcessWide exists for asymmetric designs: a very hot fast path that uses no fences, and a rare slow path that pays to synchronise all cores (some runtime internals and high-performance libraries use this trick).

4. A method for reasoning about handoffs

1. List every variable shared between threads.
2. For each handoff, identify the publish store and the observe load.
3. Make publish a release and observe an acquire (or use a lock).
4. Look for store-then-load of different variables that must not reorder: those need a full fence.
5. Check atomicity separately: ordering doesn't make read-modify-write atomic.
6. Write a stress test and run it on Arm64.

5. Double-checked locking in .NET

private Expensive? _instance;
public Expensive Instance =>
    LazyInitializer.EnsureInitialized(ref _instance, () => new Expensive());

Hand-written double-checked locking can be correct in .NET with a volatile/Volatile field, but it's easy to break during maintenance. Lazy<T> / LazyInitializer encode the right barriers once.

6. Version notes

7. Try it yourself

1. Run the Dekker code example many times; then uncomment the barriers and compare counts.
2. Run it on an Arm64 machine and compare frequencies with x64.
3. Implement the SPSC ring with plain writes, stress it on Arm64 with checksummed payloads, then add Volatile and re-run.
4. Replace the ring with Channel.CreateBounded<T>(new BoundedChannelOptions(1024) { SingleReader = true, SingleWriter = true }) and benchmark.
5. View Interlocked.MemoryBarrier() and Volatile.Write in SharpLab's JIT Asm view for x64 and Arm64.

using System.Threading;

// Store-load reordering demo (Dekker). Without the fence, both threads can read 0.
int bothSawZero = 0;
for (int i = 0; i < 200_000; i++)
{
    var t = new Trial();
    var a = Task.Run(t.A);
    var b = Task.Run(t.B);
    Task.WaitAll(a, b);
    if (t.SeenByA == 0 && t.SeenByB == 0) bothSawZero++;
}
Console.WriteLine($"Both saw zero (no fence): {bothSawZero}");

// Correct lazy initialisation without hand-written barriers.
Expensive? instance = null;
var value = LazyInitializer.EnsureInitialized(ref instance, () => new Expensive());
Console.WriteLine(value.CreatedAt);

public sealed class Trial
{
    private int _flagA, _flagB;
    public int SeenByA, SeenByB;

    public void A()
    {
        _flagA = 1;
        // Interlocked.MemoryBarrier(); // uncomment: store-load reordering prevented
        SeenByA = _flagB;
    }

    public void B()
    {
        _flagB = 1;
        // Interlocked.MemoryBarrier();
        SeenByB = _flagA;
    }
}

public sealed class Expensive
{
    public DateTime CreatedAt { get; } = DateTime.UtcNow;
}

The count depends on hardware and timing; the starting of tasks adds noise, so a zero result without the fence does not prove the code is correct.