Calling pthread_cond_signal without locking mutex

by

If you do not lock the mutex in the codepath that changes the condition and signals, you can lose wakeups. Consider this pair of processes:

Process A:

pthread_mutex_lock(&mutex);
while (condition == FALSE)
    pthread_cond_wait(&cond, &mutex);
pthread_mutex_unlock(&mutex);

Process B (incorrect):

condition = TRUE;
pthread_cond_signal(&cond);

Then consider this possible interleaving of instructions, where condition starts out as FALSE:

Process A                             Process B

pthread_mutex_lock(&mutex);
while (condition == FALSE)

                                      condition = TRUE;
                                      pthread_cond_signal(&cond);

pthread_cond_wait(&cond, &mutex);

The condition is now TRUE, but Process A is stuck waiting on the condition variable – it missed the wakeup signal. If we alter Process B to lock the mutex:

Process B (correct):

pthread_mutex_lock(&mutex);
condition = TRUE;
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);

…then the above cannot occur; the wakeup will never be missed.

(Note that you can actually move the pthread_cond_signal() itself after the pthread_mutex_unlock(), but this can result in less optimal scheduling of threads, and you’ve necessarily locked the mutex already in this code path due to changing the condition itself).

More Related Contents:

  1. Why do pthreads’ condition variable functions require a mutex?
  2. Share condition variable & mutex between processes: does mutex have to locked before?
  3. condition variable – why calling pthread_cond_signal() before calling pthread_cond_wait() is a logical error?
  4. Do pthread mutexes work across threads if in shared memory?
  5. POSIX threads and signals
  6. understanding of pthread_cond_wait() and pthread_cond_signal()
  7. Do I have to acquire lock before calling condition_variable.notify_one()?
  8. C++11 thread-safe queue
  9. How can I catch a ctrl-c event?
  10. How to increase thread priority in pthreads?
  11. Does pthread_cond_wait(&cond_t, &mutex); unlock and then lock the mutex?
  12. Cancelling a thread using pthread_cancel : good practice or bad
  13. Is it possible to determine the thread holding a mutex?
  14. Multi-threading benchmarking issues
  15. pthreads: thread starvation caused by quick re-locking
  16. Check to see if a pthread mutex is locked or unlocked (After a thread has locked itself)
  17. Signal handling in pthreads
  18. Using pthread in c++
  19. Why is locking a std::mutex twice ‘Undefined Behaviour’?
  20. Is it smart to replace boost::thread and boost::mutex with c++11 equivalents?
  21. C++11 equivalent to boost shared_mutex
  22. Throwing an exception from within a signal handler
  23. std::mutex performance compared to win32 CRITICAL_SECTION
  24. Does std::mutex create a fence?
  25. C++11 std::threads vs posix threads
  26. PTHREAD_MUTEX_INITIALIZER vs pthread_mutex_init ( &mutex, param)
  27. How much overhead is there when creating a thread?
  28. How to get CMake to recognize pthread on Ubuntu?
  29. C++11 memory_order_acquire and memory_order_release semantics?
  30. Using condition variable in a producer-consumer situation

Leave a Comment