如何让线程同时等待两个独立的条件变量？

嘿，这个问题问得很到位！首先明确一点：你没法直接让一个线程同时等待两个独立的条件变量——不管是POSIX pthread库还是C++标准库，原生的条件变量等待接口都是一次只能绑定一个变量，而且等待时必须持有对应的互斥锁，同时持有两个不同锁去等两个条件变量很容易触发死锁，完全不推荐。

不过别急，我们有几种靠谱的替代方案，能完美实现你的需求：让线程在条件A或B触发时都能唤醒，还能区分到底是哪个条件触发的。

方案1：单一条件变量 + 复合判断逻辑（最推荐） #

这是工业界最常用的做法，逻辑清晰、线程安全且跨平台，核心思路是把两个条件合并成一个复合判断，用同一个互斥锁和条件变量来管理。

实现步骤 #

1. 定义一个互斥锁（用来保护共享状态）
2. 定义一个条件变量（用来触发唤醒）
3. 定义两个布尔标记，分别记录条件A和B是否满足（必须在互斥锁保护下读写）

代码示例（C++） #

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

std::mutex mtx;
std::condition_variable cv;
bool condA = false;
bool condB = false;

// 等待线程逻辑
void waiting_thread() {
    std::unique_lock<std::mutex> lock(mtx);
    // 循环等待，防止虚假唤醒（系统可能无理由唤醒线程）
    cv.wait(lock, []{ return condA || condB; });

    // 区分触发条件并处理
    if (condA) {
        std::cout << "条件A触发，开始处理..." << std::endl;
        condA = false; // 重置标记，按需调整
    }
    if (condB) {
        std::cout << "条件B触发，开始处理..." << std::endl;
        condB = false; // 重置标记，按需调整
    }
}

// 触发条件A的线程
void trigger_A() {
    std::lock_guard<std::mutex> lock(mtx);
    condA = true;
    cv.notify_one(); // 唤醒一个等待线程，用notify_all可唤醒所有
}

// 触发条件B的线程
void trigger_B() {
    std::lock_guard<std::mutex> lock(mtx);
    condB = true;
    cv.notify_one();
}

int main() {
    std::thread waiter(waiting_thread);
    // 这里可以按需选择触发A或B
    std::thread triggerA(trigger_A);
    // std::thread triggerB(trigger_B);

    waiter.join();
    triggerA.join();
    // triggerB.join();
    return 0;
}

优点 #

• 逻辑简单易懂，维护成本低
• 完全线程安全，避免死锁风险
• 跨平台兼容，支持所有主流编程语言的线程库

方案2：基于事件文件描述符的多事件监听（高效场景适用） #

如果你的场景需要更低的延迟、更高的并发效率，可以用系统级的事件通知机制（比如Linux的eventfd+epoll），把条件A和B转换成文件描述符事件，然后用epoll_wait同时监听多个事件。

代码示例（Linux C） #

#include <sys/epoll.h>
#include <sys/eventfd.h>
#include <unistd.h>
#include <stdio.h>
#include <stdint.h>

int main() {
    // 创建两个eventfd，用来传递条件触发信号
    int fdA = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
    int fdB = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);

    // 初始化epoll实例
    int epfd = epoll_create1(EFD_CLOEXEC);
    struct epoll_event ev;
    ev.events = EPOLLIN; // 监听读事件

    // 将两个eventfd添加到epoll监听列表
    ev.data.fd = fdA;
    epoll_ctl(epfd, EPOLL_CTL_ADD, fdA, &ev);
    ev.data.fd = fdB;
    epoll_ctl(epfd, EPOLL_CTL_ADD, fdB, &ev);

    // 等待线程逻辑：无限监听事件
    struct epoll_event events[2];
    printf("等待条件触发...\n");
    int n = epoll_wait(epfd, events, 2, -1); // 无限等待，直到有事件触发

    for (int i = 0; i < n; i++) {
        uint64_t val;
        if (events[i].data.fd == fdA) {
            read(fdA, &val, sizeof(val));
            printf("条件A触发！\n");
        } else if (events[i].data.fd == fdB) {
            read(fdB, &val, sizeof(val));
            printf("条件B触发！\n");
        }
    }

    // 清理资源
    close(fdA);
    close(fdB);
    close(epfd);
    return 0;
}

触发条件的方式 #

在其他线程中，只需往对应的eventfd写入一个值即可触发：

// 触发条件A
uint64_t val = 1;
write(fdA, &val, sizeof(val));

优点 #

• 延迟极低，适合高性能场景
• 可以同时监听成百上千个事件，扩展性强
• 天然支持IO事件和同步事件混合监听

缺点 #

• 依赖特定系统API（比如Linux的epoll），跨平台性稍差
• 代码复杂度比方案1高

方案3：轮询两个条件变量（不推荐） #

还有一种思路是让线程轮流等待两个条件变量，每次等待设置一个超时时间，但这个方案缺点很明显：会引入不必要的延迟，还可能浪费CPU资源，而且如果两个条件同时触发，可能出现处理顺序混乱的问题。除非你有特殊的历史代码兼容需求，否则不建议使用。

内容的提问来源于stack exchange，提问作者Christopher Pisz