How does the lock statement work in C#, and what changed with System.Threading.Lock in .NET 9 and C# 13?

1. How Monitor uses the object header

Every reference-type object has an object header word before its MethodTable pointer.

[ object header ][ MethodTable* ][ fields... ]
       |
       +-- thin lock: owning thread id + recursion count (uncontended fast path)
       +-- or: index of a SyncBlock (after contention, or if the header is needed for a hash code)

• Uncontended: Monitor.Enter does an interlocked compare-exchange on the header: tens of nanoseconds.
• Contended: the thread spins briefly (adaptive), then the lock inflates to a sync block with a kernel-backed wait. Waiting threads block and are woken on Exit.
• GetHashCode (default identity hash) also uses the header, so hashed objects can force sync-block allocation when locked.

System.Threading.Lock keeps its state in its own fields, so it never touches object headers or sync blocks, and it can use a simpler, tuned spin/wait strategy.

2. Re-entrancy

lock (_lock)
{
    lock (_lock) { /* same thread: allowed, recursion count 2 */ }
}

Re-entrancy prevents self-deadlock but can hide design problems: a method calling back into the same object while its invariants are temporarily broken.

3. Why await is forbidden inside lock

Thread 7: Monitor.Enter(_gate)  -> await I/O -> method suspends, thread 7 returns to the pool
          continuation resumes on thread 12 -> Monitor.Exit(_gate) from thread 12
          -> SynchronizationLockException (thread 12 doesn't own it); thread 7 "owns" it forever

The compiler blocks this (CS1996). The async equivalent:

private readonly SemaphoreSlim _mutex = new(1, 1);

await _mutex.WaitAsync(ct);
try { await UpdateAsync(ct); }
finally { _mutex.Release(); }

4. Deadlock by lock ordering

// Thread A                     // Thread B
lock (_accounts) {              lock (_ledger) {
    lock (_ledger) { ... }          lock (_accounts) { ... }   // A waits for B, B waits for A
}                               }

Fixes: a global lock order (always _accounts then _ledger), one coarser lock, Monitor.TryEnter/Lock.TryEnter with timeouts plus back-off, or redesign to avoid nested locks.

5. Memory model in one table

6. Diagnosing contention

7. Version notes

8. Try it yourself

1. Run the code example; remove the lock and observe a wrong balance.
2. Paste a lock on object and on Lock into SharpLab and compare the lowered code.
3. Benchmark contended lock(object) vs lock(Lock) with 8 threads using BenchmarkDotNet.
4. Write the two-lock deadlock, take a dump, and run syncblk and clrstack -all.
5. Put Thread.Sleep(50) inside the lock under load and watch dotnet.monitor.lock_contentions climb.
6. Try await inside a lock and read CS1996; rewrite with SemaphoreSlim.

using System.Threading;

var account = new Account();
await Task.WhenAll(Enumerable.Range(0, 8).Select(_ => Task.Run(() =>
{
    for (int i = 0; i < 100_000; i++) account.Deposit(1);
})));
Console.WriteLine(account.Balance); // 800000

public sealed class Account
{
    private readonly Lock _lock = new(); // .NET 9+, C# 13
    private decimal _balance;

    public decimal Balance
    {
        get { lock (_lock) return _balance; }
    }

    public void Deposit(decimal amount)
    {
        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(amount);
        lock (_lock)
        {
            _balance += amount; // short, no I/O, no awaits
        }
    }

    public bool TryWithdraw(decimal amount)
    {
        lock (_lock)
        {
            if (_balance < amount) return false;
            _balance -= amount;
            return true;
        }
    }
}