# std::condition_variable::notify_all

< cpp‎ | thread‎ | condition variable

void notify_all() noexcept; |  | (C++11 起)

解阻塞全部当前等待于 *this 的线程。

### 参数

（无）

### 返回值

（无）

### 注意

`notify_one()`/`notify_all()` 的效果与 `wait()`/`wait_for()`/`wait_until()` 的三个原子部分的每一者（解锁+等待、唤醒和锁定）以能看做原子变量修改顺序单独全序发生：顺序对此单独的 condition_variable 是特定的。譬如，这使得 `notify_one()` 不可能被延迟并解锁正好在进行 `notify_one()` 调用后开始等待的线程。

通知线程不必保有与等待线程所保有者相同互斥的锁；实际上这么做是劣化，因为被通知线程将立即再次阻塞，以等待通知线程释放锁。

### 示例

    #include <iostream>
    #include <condition_variable>
    #include <thread>
    #include <chrono>

    std::condition_variable cv;
    std::mutex cv_m; // 此互斥用于三个目的：
                     // 1) 同步到 i 的访问
                     // 2) 同步到 std::cerr 的访问
                     // 3) 为条件变量 cv
    int i = 0;

    void waits()
    {
        std::unique_lock<std::mutex> lk(cv_m);
        std::cerr << "Waiting... \n";
        cv.wait(lk, []{return i == 1;});
        std::cerr << "...finished waiting. i == 1\n";
    }

    void signals()
    {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        {
            std::lock_guard<std::mutex> lk(cv_m);
            std::cerr << "Notifying...\n";
        }
        cv.notify_all();

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

        {
            std::lock_guard<std::mutex> lk(cv_m);
            i = 1;
            std::cerr << "Notifying again...\n";
        }
        cv.notify_all();
    }

    int main()
    {
        std::thread t1(waits), t2(waits), t3(waits), t4(signals);
        t1.join();
        t2.join();
        t3.join();
        t4.join();
    }

可能的输出：

    Waiting...
    Waiting...
    Waiting...
    Notifying...
    Notifying again...
    ...finished waiting. i == 1
    ...finished waiting. i == 1
    ...finished waiting. i == 1

### 参阅

notify_one | 通知一个等待的线程 (公开成员函数)