How can I use C++ thread library for async synchronization?

How can I use the C++ thread library for async synchronization?

You can use the C++ thread library to create threads that run asynchronously. For synchronization, you can use mutexes, condition variables, or futures.

Can you give me an example of using a mutex for synchronization?

Sure! Here's a simple example:

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;
int shared_data = 0;

void increment() {
    mtx.lock();
    ++shared_data;
    mtx.unlock();
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Shared data: " << shared_data << std::endl;
}

What are condition variables and how do they work?

Condition variables are used to block a thread until a particular condition is met. They work with mutexes to allow threads to wait for certain conditions to be true before proceeding.

Can you show me an example of using a condition variable?

Certainly! Here's a basic example:

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void wait_for_signal() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return ready; });
    std::cout << "Thread proceeding after signal!" << std::endl;
}

void send_signal() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::lock_guard<std::mutex> lock(mtx);
    ready = true;
    cv.notify_one();
}

int main() {
    std::thread waiter(wait_for_signal);
    std::thread signaler(send_signal);
    waiter.join();
    signaler.join();
}