Can someone help me understand wait() and condition_variables?
Hello All,
I found this code online but it just doesn't seem to make any sense to me.
Code:
#include <iostream>
#include <string>
#include <thread>
#include <mutex>
#include <condition_variable>
std::mutex m;
std::condition_variable cv;
std::string data;
bool ready = false;
bool processed = false;
void worker_thread()
{
// Wait until main() sends data
{
std::unique_lock<std::mutex> lk(m);
cv.wait(lk, []{return ready;});
}
std::cout << "Worker thread is processing data\n";
data += " after processing";
// Send data back to main()
{
std::lock_guard<std::mutex> lk(m);
processed = true;
std::cout << "Worker thread signals data processing completed\n";
}
cv.notify_one();
}
int main()
{
std::thread worker(worker_thread);
data = "Example data";
// send data to the worker thread
{
std::lock_guard<std::mutex> lk(m);
ready = true;
std::cout << "main() signals data ready for processing\n";
}
cv.notify_one();
// wait for the worker
{
std::unique_lock<std::mutex> lk(m);
cv.wait(lk, []{return processed;});
}
std::cout << "Back in main(), data = " << data << '\n';
worker.join();
}
Okay, so let's talk about what I understand from this code.
We're in the main-loop and we call a separate thread, passing to it the worker_thread function. Fair enough. Sticking to the main loop, we initialize a string and set it equal to "Example data". Fair enough.
I just don't get how the data is sent between these threads.
Mostly, this unique_lock and lock_guard thing. I guess I should do more reading but from the way the code is written, it seems like lock_guard needs to be called first and the same mutex shared between the threads needs to be passed as an argument. I guess that makes sense?
I just don't get the use of wait() and why is there a lambda being passed to it? What purpose does returning a boolean do in the context of wait()? Does it have something to do with the lock_guard?
And notify_one(), this is supposed to spuriously wake a thread, right?
Gah, I feel so lost...
