std::condition_variable 复杂用法

std::condition_variable 是 C++11 标准库中的一个同步原语，用于实现线程间的协作。它通常与 std::unique_lock<std::mutex> 搭配使用，可以实现以下复杂用法：

1. 等待某个条件变量满足特定条件。

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

void worker_thread()
{
    // 等待主线程通知
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; });

    // 执行任务
    // ...

    // 通知主线程任务已完成
    ready = false;
    cv.notify_one();
}

void main_thread()
{
    // 启动工作线程
    std::thread t(worker_thread);

    // 执行任务
    // ...

    // 通知工作线程任务已完成
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_one();

    // 等待工作线程完成任务
    {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, []{ return !ready; });
    }

    // 等待工作线程退出
    t.join();
}

2. 等待某个条件变量满足特定条件，并设置超时时间。

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

void worker_thread()
{
    // 等待主线程通知
    std::unique_lock<std::mutex> lock(mtx);
    if (cv.wait_for(lock, std::chrono::seconds(1), []{ return ready; })) {
        // 执行任务
        // ...
    } else {
        // 超时处理
        // ...
    }

    // 通知主线程任务已完成
    ready = false;
    cv.notify_one();
}

void main_thread()
{
    // 启动工作线程
    std::thread t(worker_thread);

    // 执行任务
    // ...

    // 通知工作线程任务已完成
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_one();

    // 等待工作线程完成任务
    {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, []{ return !ready; });
    }

    // 等待工作线程退出
    t.join();
}

3. 使用多个条件变量协调多个线程。

std::mutex mtx;
std::condition_variable cvA, cvB;
bool flagA = false, flagB = false;

void worker_thread_A()
{
    // 执行任务
    // ...

    // 通知主线程任务已完成
    {
        std::lock_guard<std::mutex> lock(mtx);
        flagA = true;
    }
    cvA.notify_one();
}

void worker_thread_B()
{
    // 执行任务
    // ...

    // 通知主线程任务已完成
    {
        std::lock_guard<std::mutex> lock(mtx);
        flagB = true;
    }
    cvB.notify_one();
}

void main_thread()
{
    // 启动工作线程
    std::thread tA(worker_thread_A), tB(worker_thread_B);

    // 等待工作线程 A 和 B 完成任务
    {
        std::unique_lock<std::mutex> lock(mtx);
        cvA.wait(lock, []{ return flagA; });
        cvB.wait(lock, []{ return flagB; });
    }

    // 执行任务
    // ...

    // 通知工作线程 A 和 B 任务已完成
    {
        std::lock_guard<std::mutex> lock(mtx);
        flagA = false;
        flagB = false;
    }
    cvA.notify_one();
    cvB.notify_one();

    // 等待工作线程 A 和 B 退出
    tA.join();
    tB.join();
}