notify_one()和notify_all()

notify_one()和notify_all()是C++中多线程编程的两个方法。它们用于唤醒在等待某个条件变量的线程。其中，notify_one()会随机唤醒一个等待线程，而notify_all()会唤醒所有等待线程。

相关问题

Cpp notify_all 和 notify_one使用实例

notify_all 和 notify_one 都是 C++ 中的条件变量（condition variable）的成员函数，用于唤醒等待线程。

下面是一个简单的使用实例：

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

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

void worker(int id)
{
    std::unique_lock<std::mutex> lock(mtx);
    while (!ready) {
        std::cout << "Worker " << id << " is waiting..." << std::endl;
        cv.wait(lock);
    }
    std::cout << "Worker " << id << " is working..." << std::endl;
}

void notifier()
{
    std::unique_lock<std::mutex> lock(mtx);
    ready = true;
    cv.notify_all();
}

int main()
{
    std::thread t1(worker, 1);
    std::thread t2(worker, 2);
    std::thread t3(worker, 3);

    std::this_thread::sleep_for(std::chrono::seconds(1));

    std::thread t4(notifier);

    t1.join();
    t2.join();
    t3.join();
    t4.join();

    return 0;
}

上面的代码创建了三个 worker 线程和一个 notifier 线程。worker 线程会等待 ready 变量为 true，notifier 线程会将 ready 变量设置为 true，并通过 notify_all 函数唤醒所有等待线程。

运行上面的代码，输出结果如下：

Worker 1 is waiting...
Worker 2 is waiting...
Worker 3 is waiting...
Worker 3 is working...
Worker 2 is working...
Worker 1 is working...

可以看到，三个 worker 线程都等待在条件变量上，直到 notifier 线程唤醒它们，并且它们同时开始工作。如果将 notify_all 改为 notify_one，那么只会唤醒一个等待线程，输出结果会有所不同。

cpp condition_variable notify_all notify_one使用经典实例，逐行代码讲解

好的，下面我来给你讲解一下 `condition_variable` 的经典使用实例，包括 `notify_all` 和 `notify_one` 的使用。

首先，我们需要定义一个 `std::mutex` 和一个 `std::condition_variable`，用来实现线程之间的同步和通信。

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

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

在这个例子中，我们定义了一个 `bool` 类型的变量 `ready`，用来表示线程是否准备好了。同时，我们定义了一个互斥锁 `mtx` 和一个条件变量 `cv`，用来保护 `ready` 变量，防止多个线程同时访问和修改。

接下来，我们定义两个线程，一个线程用来等待 `ready` 变量变为 `true`，另一个线程用来修改 `ready` 变量为 `true`。

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

    // 等待结束，do something
    std::cout << "Worker thread is processing data...\n";
}

int main()
{
    // 创建工作线程
    std::thread worker(worker_thread);

    // 等待一段时间
    std::this_thread::sleep_for(std::chrono::seconds(2));

    // 修改 ready 变量为 true
    {
        std::lock_guard<std::mutex> lck(mtx);
        ready = true;
    }

    // 通知工作线程
    cv.notify_one();

    // 等待工作线程结束
    worker.join();

    return 0;
}

在 `main()` 函数中，我们创建了一个工作线程 `worker`，并且在主线程中等待 2 秒钟，模拟工作线程需要等待一段时间才能开始处理数据。

在等待结束后，我们修改了 `ready` 变量为 `true`，并且调用了 `cv.notify_one()` 来通知等待的工作线程可以开始处理数据了。

在工作线程中，我们首先使用 `std::unique_lock<std::mutex>` 对互斥锁进行了锁定，并且调用了 `cv.wait(lck, []{ return ready; })` 来等待条件变量的通知。

`cv.wait()` 函数的作用是使当前线程等待条件变量的通知，当条件变量被通知后，线程会被唤醒，继续执行后面的代码。 `cv.wait()` 函数会自动释放互斥锁，并且在等待期间阻塞当前线程。

在等待期间，工作线程会一直等待，直到主线程调用 `cv.notify_one()` 来通知工作线程可以开始处理数据了。

当工作线程被唤醒后，它会继续执行后面的代码，并且输出一条信息，表示正在处理数据。

这就是 `condition_variable` 的经典使用实例，通过 `notify_all` 和 `notify_one` 函数来实现线程之间的同步和通信。