C++ wait/notify机制

最新推荐文章于 2025-10-19 21:08:32 发布

转载最新推荐文章于 2025-10-19 21:08:32 发布 · 8.9k 阅读

21 ·

CC 4.0 BY-SA版权

原文链接：https://www.cnblogs.com/qbin/p/11608807.html

S4: C++ (抽象和接口) 专栏收录该内容

81 篇文章

订阅专栏

本文详细解析C++中的wait/notify机制，包括notify_one和notify_all的区别，以及如何在threadA、threadB和threadC中实现线程间的有序唤醒。通过实例演示了条件变量和互斥锁的使用，帮助理解线程间的协作与控制。

C++ wait/notify机制

notify_one：唤醒等待线程中的一个，唤醒的线程顺序执行。
notify_all：唤醒所有等待的线程，唤醒的线程抢占式执行。
wait：等待。需要其它的接口来唤醒。

instance analysis

#include <iostream>
#include <thread>
#include <condition_variable>
#include <mutex>//demo
#include <unistd.h>

std::mutex mtx_syn;
std::condition_variable cv_syn;
std::condition_variable cv_syn_1;
bool ready = false;//线程A

void threadA(int id)
{
    while (1)
    {
        std::unique_lock<std::mutex> lck(mtx_syn);
        while (!ready)
        {
            cv_syn.wait(lck);
        }
        // ...
        std::cout << "threadA " << id << '\n';
        usleep(500*1000);
        cv_syn.notify_one();   // 唤醒等待线程中的一个
        cv_syn.wait(lck);      // 等待
    }

}// 线程B
void threadB(int id)
{
    while (1)
    {
        //新创建的 unique_lock 对象管理 Mutex 对象 m，并尝试调用 m.lock() 对 Mutex 对象进行上锁，如果此时另外某个 unique_lock 对象已经管理了该 Mutex 对象 m，则当前线程将会被阻塞
        std::unique_lock<std::mutex> lck(mtx_syn);
        while (!ready)
        {
            cv_syn.wait(lck);
        }
        // ...
        std::cout << "threadB " << id << '\n';
        usleep(500*1000);
	cv_syn.notify_one();// 唤醒等待线程中的一个
	cv_syn.wait(lck);
    }
}

// 线程C
void threadC(int id)
{
    while (1)
    {
        std::unique_lock<std::mutex> lck(mtx_syn);
        while (!ready) cv_syn.wait(lck);
        // ...
        std::cout << "threadC " << id << '\n';
        usleep(500*1000);
        cv_syn.notify_one();  // 唤醒等待线程中的一个线程
        cv_syn.wait(lck);
    }
}


void go()
{
    std::unique_lock<std::mutex> lck(mtx_syn);
    ready = true;
    //cv_syn.notify_one(); // 唤醒等待线程中的一个线程，notify_one()唤醒的线程顺序执行
    cv_syn.notify_all();  //唤醒的线程抢占式知性
}

int main()
{
    //线程同步
    std::thread threads[5];
    threads[0] = std::thread(threadA, 0);
    threads[1] = std::thread(threadB, 1);
    threads[2] = std::thread(threadC, 2);
    std::cout << "3 threads ready to race...\n";
    go();                       // go!

    for (auto& th : threads) th.join();
}

g++ main.cpp -o main -std=c++11 -lpthread