When is a condition variable needed, isn’t a mutex enough?

by

Even though you can use them in the way you describe, mutexes weren’t designed for use as a notification/synchronization mechanism. They are meant to provide mutually exclusive access to a shared resource. Using mutexes to signal a condition is awkward and I suppose would look something like this (where Thread1 is signaled by Thread2):

Thread1:

while(1) {
    lock(mutex); // Blocks waiting for notification from Thread2
    ... // do work after notification is received
    unlock(mutex); // Tells Thread2 we are done
}

Thread2:

while(1) {
    ... // do the work that precedes notification
    unlock(mutex); // unblocks Thread1
    lock(mutex); // lock the mutex so Thread1 will block again
}

There are several problems with this:

  1. Thread2 cannot continue to “do the work that precedes notification” until Thread1 has finished with “work after notification”. With this design, Thread2 is not even necessary, that is, why not move “work that precedes” and “work after notification” into the same thread since only one can run at a given time!
  2. If Thread2 is not able to preempt Thread1, Thread1 will immediately re-lock the mutex when it repeats the while(1) loop and Thread1 will go about doing the “work after notification” even though there was no notification. This means you must somehow guarantee that Thread2 will lock the mutex before Thread1 does. How do you do that? Maybe force a schedule event by sleeping or by some other OS-specific means but even this is not guaranteed to work depending on timing, your OS, and the scheduling algorithm.

These two problems aren’t minor, in fact, they are both major design flaws and latent bugs. The origin of both of these problems is the requirement that a mutex is locked and unlocked within the same thread. So how do you avoid the above problems? Use condition variables!

BTW, if your synchronization needs are really simple, you could use a plain old semaphore which avoids the additional complexity of condition variables.

More Related Contents:

  1. Is it possible to use mutex in multiprocessing case on Linux/UNIX ?
  2. Conditional Variable vs Semaphore
  3. Which is more efficient, basic mutex lock or atomic integer?
  4. What is the difference between a process and a thread?
  5. What is a mutex?
  6. Recursive Lock (Mutex) vs Non-Recursive Lock (Mutex)
  7. Mutex example / tutorial? [closed]
  8. What resources are shared between threads?
  9. When should we use mutex and when should we use semaphore
  10. How efficient is locking an unlocked mutex? What is the cost of a mutex?
  11. What are the differences between various threading synchronization options in C#?
  12. Using string as a lock to do thread synchronization
  13. fork in multi-threaded program
  14. How efficient is locking and unlocked mutex? What is the cost of a mutex?
  15. Difference between user-level and kernel-supported threads?
  16. How do I run parallel threads of computation on a partitioned array?
  17. Do lock-free algorithms really perform better than their lock-full counterparts?
  18. How to synchronize a static variable among threads running different instances of a class in Java?
  19. What will be used for data exchange between threads are executing on one Core with HT?
  20. Java double checked locking
  21. Atomic UPDATE .. SELECT in Postgres
  22. How to make Qt work when main thread is busy?
  23. Doxygen is Slow
  24. How to give priority to privileged thread in mutex locking?
  25. Running two threads at the same time
  26. Multithreading: What is the point of more threads than cores?
  27. How does x86 pause instruction work in spinlock *and* can it be used in other scenarios?
  28. “Collection was mutated while being enumerated” on executeFetchRequest
  29. ReleaseSemaphore does not release the semaphore
  30. What makes the execution order of threads unpredictable?

Leave a Comment