信号量虚假唤醒，wait（）自己醒来，即使没有notify（原因，底层线程同时竞争锁与信号条件），只能在外部循环检测，while（！ready）

本文链接：https://blog.youkuaiyun.com/zjkyeah/article/details/146224688

虚假唤醒（Spurious Wakeup）详解

你可能还是不太理解 虚假唤醒（Spurious Wakeup），我们来从 底层机制、示例代码、操作系统行为 详细讲解它的本质和 如何防止。

1. 什么是虚假唤醒？

虚假唤醒（Spurious Wakeup） 是指：

线程调用 wait() 进入等待状态后，可能会在没有 notify_one() 或 notify_all() 触发的情况下被唤醒。

换句话说：

线程本来应该 等到别的线程调用 notify_one() 或 notify_all() 才醒来。
但它可能会 莫名其妙地提前醒来，即使 ready 变量的条件 还没有满足！

2. 为什么会发生虚假唤醒？（底层原因分析）

虚假唤醒通常由以下 操作系统和线程管理机制 造成：

(1) 内核调度机制

操作系统的调度器可能会随机唤醒线程，即使 notify_one() 还没被调用：

在一些 高负载、多线程 环境下，内核可能会尝试 提前调度等待线程，让它们重新检查条件。
这有助于提高系统吞吐量，但对应用程序来说，线程可能会莫名其妙地醒来。

(2) `pthread_cond_signal()` 可能唤醒多个线程

notify_one() 底层调用的是 pthread_cond_signal()，它本来应该只通知一个线程，但：

某些实现（特别是老版本的 POSIX 线程） 可能会错误地唤醒多个线程。
这意味着 即使 notify_one() 只通知了 T1，T2 可能也会醒来！

(3) `pthread_cond_wait()` 在某些系统上的实现方式

pthread_cond_wait() 并不完全是一个“阻塞调用”，它的内部机制类似于：

void pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) {
    unlock(mutex);  // 释放互斥锁
    semaphore_wait(cond->semaphore);  // 进入等待队列
    lock(mutex);  // 重新获取锁
}

某些系统可能会意外触发 semaphore_wait() 返回，导致 wait() 立即返回，而不是真的收到 notify_one() 信号。

(4) 竞争条件

假设 T1 进入 cv.wait() 之后，notify_one() 唤醒它，但在 T1 重新获取 mutex 之前：

T2 可能误以为 T1 没有醒来，再调用 notify_one()，导致 T1 收到两个信号。
这可能会导致 T1 先被虚假唤醒一次，再被真正唤醒一次。

3. 代码示例：虚假唤醒

#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);
    std::cout << "Thread " << id << " waiting...\n";
    
    while (!ready) {  // 必须用 while，而不是 if
        cv.wait(lock);
    }
    
    std::cout << "Thread " << id << " proceeding...\n";
}

void notify() {
    std::unique_lock<std::mutex> lock(mtx);
    ready = true;
    cv.notify_one();  // 唤醒一个线程
}

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

    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 确保 t1/t2 进入 wait
    notify();  // 唤醒一个线程

    t1.join();
    t2.join();
    return 0;
}

可能的输出

Thread 1 waiting...
Thread 2 waiting...
Thread 1 proceeding...
Thread 2 proceeding...  // ❌ 这是虚假唤醒，T2 本不应该醒来！

notify_one() 只通知了一个线程，但 T2 也醒来了！
这就是虚假唤醒，它可能导致 逻辑错误。

4. 为什么 `while (!ready)` 能防止虚假唤醒？

如果你把 while (!ready) 换成 if (!ready)：

if (!ready) {
    cv.wait(lock);
}

wait() 可能虚假唤醒，但 if 语句不会再检查 ready，导致错误执行！
解决方案：使用 while 确保线程真正满足 ready == true 之后才执行：

while (!ready) {
    cv.wait(lock);
}

如果 wait() 由于虚假唤醒提前返回，它会再次检查 ready，如果不满足条件，就继续等待。

5. 总结

问题	现象	原因	解决方案
虚假唤醒	线程提前返回 `wait()`，即使 `notify_one()` 没有调用	操作系统调度、信号竞争、POSIX 线程实现方式	用 `while (!ready)` 重新检查
多个线程被 `notify_one()` 唤醒	`notify_one()` 只通知一个线程，但多个线程执行	竞争条件、调度问题	确保 `ready` 变量的正确性
`if (!ready) cv.wait()` 可能导致逻辑错误	一个线程提前被唤醒后，执行了错误代码	`if` 只检查一次，不会重新检查 `ready`	用 `while (!ready)` 代替 `if (!ready)`