Unlock a thread from another thread in C++11

Question

I'm not extensively knowledgeable in terms on the thread.h api of the C++11 (in fact I'm not familiar with thread progranmming either, but I read on it recently quite a lot and know about the concurrency and stuff like that) but I started using it and I'm facing a problem that I haven't really ever faced yet.

I have two thread functions, say these

std::thread(thread1, args); // Spawn thread 1
std::thread(thread2, args); // Spawn thread 2

[...]

int thread1(bunch of args)
{
     lock_thread_2();
     [do stuff]
     while (some condition) {
         [do stuff]
         unlock_thread_2();
     }
}

int thread2(bunch of args)
{
     while (some condition) {
         [do stuff]
         wait_for_thread1_to_unlock_me();
     }
}

I first thought about doing it with a std::mutex but I read it could be dangerous because the behavior is undefined if I unlock an already-unlocked mutex and on top of it it wouldn't work anyways as mutex.lock() doesn't necessarily pause the execution (it only does if the mutex is already locked) so it'd be quite horrendous to write, I'd have to couple unlock() and lock() calls together.

What's important to note here is that thread2's execution only is controlled by thread1, but thread2 will never lock thread1 in any fashion. Only thread2 gets locked by thread1, only thread1 controls the execution flow thread2, not otherwise.

How would you do that in a clean way, supported way? Would you be kind enough to give an example of code?

Thanks!

Answer 1

Use a condition_variable:

std::condition_variable cv;

int thread1(bunch of args)
{
     [do stuff]
     while (some condition) {
         [do stuff]
         cv.notify_one();
     }
}

int thread2(bunch of args)
{
     std::mutex mtx;
     std::unique_lock<std::mutex> lk(mtx);

     while (some condition) {
         [do stuff]
         cv.wait(lk);
     }
}

When wait() returns, either cv will have been notify()-ed... or there will have been a spurious wakeup. In an effort to handle the latter, it's often helpful to add a predicate.