C# : Monitor – Wait,Pulse,PulseAll

by

Short version:

lock(obj) {...}

is short-hand for Monitor.Enter / Monitor.Exit (with exception handling etc). If nobody else has the lock, you can get it (and run your code) – otherwise your thread is blocked until the lock is aquired (by another thread releasing it).

Deadlock typically happens when either A: two threads lock things in different orders:

thread 1: lock(objA) { lock (objB) { ... } }
thread 2: lock(objB) { lock (objA) { ... } }

(here, if they each acquire the first lock, neither can ever get the second, since neither thread can exit to release their lock)

This scenario can be minimised by always locking in the same order; and you can recover (to a degree) by using Monitor.TryEnter (instead of Monitor.Enter/lock) and specifying a timeout.

or B: you can block yourself with things like winforms when thread-switching while holding a lock:

lock(obj) { // on worker
    this.Invoke((MethodInvoker) delegate { // switch to UI
        lock(obj) { // oopsiee!
            ...
        }
    });
}

The deadlock appears obvious above, but it isn’t so obvious when you have spaghetti code; possible answers: don’t thread-switch while holding locks, or use BeginInvoke so that you can at least exit the lock (letting the UI play).

Wait/Pulse/PulseAll are different; they are for signalling. I use this in this answer to signal so that:

  • Dequeue: if you try to dequeue data when the queue is empty, it waits for another thread to add data, which wakes up the blocked thread
  • Enqueue: if you try and enqueue data when the queue is full, it waits for another thread to remove data, which wakes up the blocked thread

Pulse only wakes up one thread – but I’m not brainy enough to prove that the next thread is always the one I want, so I tend to use PulseAll, and simply re-verify the conditions before continuing; as an example:

        while (queue.Count >= maxSize)
        {
            Monitor.Wait(queue);
        }

With this approach, I can safely add other meanings of Pulse, without my existing code assuming that “I woke up, therefore there is data” – which is handy when (in the same example) I later needed to add a Close() method.

More Related Contents:

  1. Maximum number of threads in a .NET app?
  2. Implement C# Generic Timeout
  3. When to use BlockingCollection and when ConcurrentBag instead of List?
  4. Starting Tasks In foreach Loop Uses Value of Last Item [duplicate]
  5. Why is cross thread operation exception not thrown while running exe in bin\Debug
  6. Is accessing a variable in C# an atomic operation?
  7. Multiple Parallel.ForEach loops in .Net
  8. Is there a way to indefinitely pause a thread?
  9. How to put a task to sleep (or delay) in C# 4.0?
  10. Task continuation on UI thread
  11. Is EndInvoke() optional, sort-of optional, or definitely not optional?
  12. Async/Await vs Threads
  13. Thread safety of a Dictionary with multiple concurrent readers and no writers
  14. Running a method in BackGroundWorker and Showing ProgressBar
  15. Run multiple UI Threads
  16. Multi threading C# application with SQL Server database calls
  17. How do I implement the Sieve Of Eratosthenes using multithreaded C#?
  18. ThreadPool not starting new Thread instantly
  19. How do I spawn threads on different CPU cores?
  20. C# Threading/Async: Running a task in the background while UI is interactable
  21. How do you pass a BitmapImage from a background thread to the UI thread in WPF?
  22. Cross-Process Locking in C#
  23. Faulted vs Canceled task status after CancellationToken.ThrowIfCancellationRequested
  24. Read and process files in parallel C#
  25. Is Stopwatch.ElapsedTicks threadsafe?
  26. Multiple UI Threads – Winforms
  27. Async and Await with For Loop [duplicate]
  28. Writing to file in a thread safe manner
  29. Using C# MethodInvoker.Invoke() for a GUI app… is this good?
  30. How can I enumerate all managed threads in C#?

Leave a Comment