What does the Monitor class provide beyond the lock statement? Explain TryEnter, Wait and Pulse.

1. What Wait really does

Monitor.Wait(_gate):
  1. verify current thread owns _gate (else SynchronizationLockException)
  2. remember recursion count (e.g. 2 if entered twice), fully release the lock
  3. add thread to _gate's waiting queue and block
  4. on Pulse/PulseAll (or timeout): move to ready queue
  5. reacquire _gate (compete with others), restore recursion count
  6. return true (pulsed) or false (timed out); the lock is held either way

Note step 6: even on timeout, Wait returns with the lock held.

2. Why while is mandatory

T1 (consumer): lock; count==0 -> Wait (releases)
T2 (consumer): lock; count==0 -> Wait (releases)
P  (producer): lock; Enqueue(x); PulseAll; unlock
T1 wakes, reacquires: Dequeue -> x     (count 0)
T2 wakes, reacquires: with `if` -> Dequeue on empty -> crash
                      with `while` -> recheck count==0 -> Wait again (correct)

The loop also protects against wake-ups caused by PulseAll for an unrelated condition.

3. Lost wake-ups with Pulse

With one monitor and two conditions (not-full, not-empty), Pulse might wake a producer when a consumer should run. If that producer just waits again, nobody wakes the consumer: a hang. PulseAll (or separate monitor objects per condition) avoids this at the cost of more wake-ups.

4. TryEnter for diagnosable locks

bool taken = false;
try
{
    Monitor.TryEnter(_gate, TimeSpan.FromSeconds(5), ref taken);
    if (!taken)
    {
        _log.LogError("Could not acquire ledger lock within 5s; possible deadlock");
        throw new TimeoutException("Ledger lock timeout");
    }
    UpdateLedger();
}
finally
{
    if (taken) Monitor.Exit(_gate);
}

This turns an invisible hang into a logged, alertable error. Very short timeouts as a "performance trick" just add failure paths.

5. Thin locks and sync blocks

This is why any reference type can be a lock, and why Monitor.Wait on an object always inflates it to a sync block. dotnet-dump's syncblk command lists sync blocks with their owners and waiters.

6. Monitor waits and Interrupt

Monitor.Wait and contended Enter are managed blocking waits, so Thread.Interrupt() can break them with ThreadInterruptedException, and they're visible as WaitSleepJoin in thread state.

7. Version notes

8. Try it yourself

1. Run the code example; then change while to if and run with three consumers and 10,000 items to reproduce failures.
2. Replace PulseAll with Pulse in both methods and look for hangs under stress.
3. Call Monitor.Pulse(_gate) outside the lock and observe SynchronizationLockException.
4. Enter the lock twice, call Wait with a timeout, and confirm the recursion count is restored (you need two Exit calls afterwards).
5. Rewrite the buffer with Channel.CreateBounded<int>(2) and compare.
6. Take a dump while threads are waiting and run syncblk.

using System.Threading;

var buffer = new BoundedBuffer<int>(capacity: 2);
var consumer = Task.Run(() =>
{
    for (int i = 0; i < 5; i++) Console.WriteLine($"Took {buffer.Take()}");
});
for (int i = 1; i <= 5; i++) buffer.Add(i);
await consumer;

public sealed class BoundedBuffer<T>(int capacity)
{
    private readonly object _gate = new();
    private readonly Queue<T> _items = new();

    public void Add(T item)
    {
        lock (_gate)
        {
            while (_items.Count == capacity) Monitor.Wait(_gate); // releases _gate while waiting
            _items.Enqueue(item);
            Monitor.PulseAll(_gate); // wake consumers (and producers)
        }
    }

    public T Take()
    {
        lock (_gate)
        {
            while (_items.Count == 0) Monitor.Wait(_gate);
            T item = _items.Dequeue();
            Monitor.PulseAll(_gate);
            return item;
        }
    }

    public bool TryAddWithin(T item, TimeSpan timeout)
    {
        bool taken = false;
        try
        {
            Monitor.TryEnter(_gate, timeout, ref taken);
            if (!taken || _items.Count == capacity) return false;
            _items.Enqueue(item);
            Monitor.PulseAll(_gate);
            return true;
        }
        finally
        {
            if (taken) Monitor.Exit(_gate);
        }
    }
}