understanding of pthread_cond_wait() and pthread_cond_signal()

by

pthread_cond_signal does not unlock the mutex (it can’t as it has no reference to the mutex, so how could it know what to unlock?) In fact, the signal need not have any connection to the mutex; the signalling thread does not need to hold the mutex, though for most algorithms based on condition variables it will.

pthread_cond_wait unlocks the mutex just before it sleeps (as you note), but then it reaquires the mutex (which may require waiting) when it is signalled, before it wakes up. So if the signalling thread holds the mutex (the usual case), the waiting thread will not proceed until the signalling thread also unlocks the mutex.

The common use of condition vars is something like:

thread 1:
    pthread_mutex_lock(&mutex);
    while (!condition)
        pthread_cond_wait(&cond, &mutex);
    /* do something that requires holding the mutex and condition is true */
    pthread_mutex_unlock(&mutex);

thread2:
    pthread_mutex_lock(&mutex);
    /* do something that might make condition true */
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&mutex);

The two threads have some shared data structure that the mutex is protecting access to. The first thread wants to wait until some condition is true then immediately do some operation (with no race condition opportunity for some other thread to come in between the condition check and action and make the condition false.) The second thread is doing something that might make the condition true, so it needs to wake up anyone that might be waiting for it.

More Related Contents:

  1. Example for boost shared_mutex (multiple reads/one write)?
  2. Mutex example / tutorial? [closed]
  3. How to give priority to privileged thread in mutex locking?
  4. How can I use something like std::vector?
  5. Is it smart to replace boost::thread and boost::mutex with c++11 equivalents?
  6. When to use recursive mutex?
  7. Does std::mutex create a fence?
  8. How to implement a unmanaged thread-safe collection when I get this error: is not supported when compiling with /clr
  9. Should a class be thread-safe? [closed]
  10. Thread pooling in C++11
  11. What does the thread_local mean in C++11?
  12. How to check if a std::thread is still running?
  13. Atomicity on x86
  14. std::lock_guard or std::scoped_lock?
  15. How would you implement your own reader/writer lock in C++11?
  16. Mixing C++11 atomics and OpenMP
  17. C++ Equivalent to Java’s BlockingQueue
  18. Multithreaded Rendering on OpenGL
  19. How to set the stacksize with C++11 std::thread
  20. How to make a multiple-read/single-write lock from more basic synchronization primitives?
  21. How do you use CreateThread for functions which are class members?
  22. clock function in C++ with threads
  23. What is the proper way of doing event handling in C++?
  24. std::map thread-safety
  25. Making a C++ class a Monitor (in the concurrent sense)
  26. C++11 std::mutex in Visual Studio 2012 deadlock when locked from DllMain()
  27. Portable Compare And Swap (atomic operations) C/C++ library?
  28. Is it possible to use threads to speed up file reading?
  29. signal handler function in multithreaded environment
  30. Loading a dll from a dll?

Leave a Comment