Does a mutex get unlocked when calling notify on a condition variable?
c++, c++11, condition-variable
Solution
Notifying does not unlock the mutex. You can tell (indirectly) because you don't pass the lock to `notify_one()` the way you do to `wait()`, which does release the mutex while it waits.
On the other side, the notified thread(s) are notified "immediately". But they won't necessarily return from `wait()` immediately. Before they can return from `wait()` they must first re-acquire the mutex, so they will block there until the notifying thread releases it.
Problem
I am trying to understand what happens to a mutex when it is used in a condition variable. In the following example, taken from cppreference ``` int main() { std::queue<int> produced_nums; std::mutex m; std::condition_variable cond_var; bool done = false; bool notified = false; std::thread producer([&]() { for (int i = 0; i < 5; ++i) { std::this_thread::sleep_for(std::chrono::seconds(1)); std::unique_lock<std::mutex> lock(m); std::cout << "producing " << i << '\n'; produced_nums.push(i); notified = true; cond_var.notify_one(); } done = true; cond_var.notify_one(); }); std::thread consumer([&]() { std::unique_lock<std::mutex> lock(m); while (!done) { while (!notified) { // loop to avoid spurious wakeups cond_var.wait(lock); } while (!produced_nums.empty()) { std::cout << "consuming " << produced_nums.front() << '\n'; produced_nums.pop(); } notified = false; } }); producer.join(); consumer.join(); } ``` The producer thread calls `cond_var.notify_one()` before the mutex gets unlocked. Does the mutex `m` get unlocked when notify is called, or does the notification occurs only when the mutex gets unlocked?