重温并发任务:Linux 多线程同步利器条件变量

typedef union{  struct __pthread_cond_s __data;  char __size[__SIZEOF_PTHREAD_COND_T];  __extension__ long long int __align;} pthread_cond_t;

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);

int pthread_cond_destroy(pthread_cond_t *cond);

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);

int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);

int pthread_cond_signal(pthread_cond_t *cond);

int pthread_cond_broadcast(pthread_cond_t *cond);

#include <stdio.h>#include <stdlib.h>#include <pthread.h>#include <unistd.h>#define BUFFER_SIZE 5typedef struct {    int buffer[BUFFER_SIZE];    int in;    int out;    int count;} CircularBuffer;CircularBuffer cb = {0};pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;pthread_cond_t not_empty = PTHREAD_COND_INITIALIZER;pthread_cond_t not_full = PTHREAD_COND_INITIALIZER;// 生产者void* producer(void *arg) {    int item = 0;    while (1) {        item++;        pthread_mutex_lock(&lock);        // 关键点1：满了就等，必须用while        while (cb.count == BUFFER_SIZE) {            printf("【生产者】缓冲区满了，休息一下...\n");            pthread_cond_wait(&not_full, &lock);        }        // 写数据        cb.buffer[cb.in] = item;        cb.in = (cb.in + 1) % BUFFER_SIZE;        cb.count++;        printf("【生产者】放入数据 %d, 当前数量: %d\n", item, cb.count);        // 唤醒消费者        pthread_cond_signal(&not_empty);        pthread_mutex_unlock(&lock);        sleep(1); // 模拟生产耗时    }    return NULL;}// 消费者void* consumer(void *arg) {    while (1) {        pthread_mutex_lock(&lock);        // 关键点2：空了就等，必须用while        while (cb.count == 0) {            printf("【消费者】缓冲区空了，等待数据...\n");            pthread_cond_wait(&not_empty, &lock);        }        // 取数据        int item = cb.buffer[cb.out];        cb.out = (cb.out + 1) % BUFFER_SIZE;        cb.count--;        printf("【消费者】取出数据 %d, 当前数量: %d\n", item, cb.count);        // 唤醒生产者        pthread_cond_signal(&not_full);        pthread_mutex_unlock(&lock);        sleep(2); // 模拟消费耗时    }    return NULL;}int main() {    pthread_t pro, con;    pthread_create(&pro, NULL, producer, NULL);    pthread_create(&con, NULL, consumer, NULL);    pthread_join(pro, NULL);    pthread_join(con, NULL);    pthread_mutex_destroy(&lock);    pthread_cond_destroy(&not_empty);    pthread_cond_destroy(&not_full);    return 0;}

示例 2：带超时的等待（BSP 场景常用）

在实际 BSP 调试或驱动开发中，我们经常不能无限等硬件。这个例子演示了 pthread_cond_timedwait 的用法。

#include <stdio.h>#include <stdlib.h>#include <pthread.h>#include <unistd.h>#include <time.h>#include <errno.h>pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;pthread_cond_t cond = PTHREAD_COND_INITIALIZER;int data_ready = 0;// 模拟硬件中断或另一个线程发送信号void* hardware_thread(void *arg) {    printf("[硬件] 正在初始化硬件...\n");    sleep(3); // 模拟硬件初始化耗时3秒    printf("[硬件] 初始化完成！\n");    pthread_mutex_lock(&mutex);    data_ready = 1;    pthread_cond_signal(&cond); // 发送信号    pthread_mutex_unlock(&mutex);    return NULL;}// 模拟应用层等待硬件void* app_thread(void *arg) {    struct timespec ts;    clock_gettime(CLOCK_REALTIME, &ts);    ts.tv_sec += 2; // 只等2秒    pthread_mutex_lock(&mutex);    printf("[应用] 等待硬件就绪 (超时2秒)...\n");    // 等待，带超时    int ret = pthread_cond_timedwait(&cond, &mutex, &ts);    if (ret == ETIMEDOUT) {        printf("[应用] 超时了！硬件可能出问题了。\n");    } else {        printf("[应用] 收到信号，硬件就绪成功！\n");    }    pthread_mutex_unlock(&mutex);    return NULL;}int main() {    pthread_t t_hw, t_app;    pthread_create(&t_hw, NULL, hardware_thread, NULL);    pthread_create(&t_app, NULL, app_thread, NULL);    pthread_join(t_hw, NULL);    pthread_join(t_app, NULL);    pthread_mutex_destroy(&mutex);    pthread_cond_destroy(&cond);    return 0;}

示例 3：广播机制

当有多个消费者线程，但只需要一个生产者发送一次通知，所有消费者都要醒来干活时，必须用 broadcast。比如重新加载配置文件。

#include <stdio.h>#include <stdlib.h>#include <pthread.h>#include <unistd.h>pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;pthread_cond_t cond = PTHREAD_COND_INITIALIZER;int config_updated = 0;void* worker(void *arg) {    int id = *(int*)arg;    pthread_mutex_lock(&lock);    while (config_updated == 0) {        printf("[Worker %d] 正在等待配置更新...\n", id);        pthread_cond_wait(&cond, &lock); // 所有线程都在这等着    }    printf("[Worker %d] 收到广播！开始应用新配置...\n", id);    pthread_mutex_unlock(&lock);    return NULL;}void* master(void *arg) {    sleep(2); // 模拟读取配置文件    pthread_mutex_lock(&lock);    config_updated = 1;    printf("[Master] 配置已更新，通知所有 Worker！\n");    pthread_cond_broadcast(&cond); // 一次性叫醒所有人    pthread_mutex_unlock(&lock);    return NULL;}int main() {    pthread_t master_tid;    pthread_t workers[3];    int ids[3] = {1, 2, 3};    pthread_create(&master_tid, NULL, master, NULL);    for(int i=0; i<3; i++) {        pthread_create(&workers[i], NULL, worker, &ids[i]);    }    pthread_join(master_tid, NULL);    for(int i=0; i<3; i++) {        pthread_join(workers[i], NULL);    }    pthread_mutex_destroy(&lock);    pthread_cond_destroy(&cond);    return 0;}

六、pthread 条件变量 的优缺点（完整总结，客观全面，选型参考）

✅ 优点（核心优势，无可替代）

1. 1. 极致的 CPU 利用率：等待条件的线程进入休眠态，不占用任何 CPU 资源，相比轮询 / 忙等，CPU 利用率趋近于 0，这是条件变量的核心优势；
2. 2. 精准的线程协作：能实现基于条件的有序执行，完美解决线程间的依赖关系，逻辑清晰、代码简洁；
3. 3. 规避虚假唤醒：通过while(条件)循环判断，可完全兼容 Linux 内核的虚假唤醒特性，线程安全；
4. 4. 低开销高并发：条件变量的唤醒 / 等待操作，都是轻量级的内核调用，开销极低，能支撑高并发场景；
5. 5. 灵活的唤醒策略：支持精准唤醒和广播唤醒，能适配所有线程协作场景；
6. 6. 超时保护机制：通过 timedwait 实现超时等待，避免线程永久阻塞，生产环境友好。

✅ 缺点（局限性，客观认知，避坑即可）

1. 1. 必须依赖互斥锁：条件变量无法独立使用，必须搭配互斥锁，增加了少量的代码复杂度；
2. 2. 存在虚假唤醒：虽然可以通过while(条件)规避，但这是内核设计特性，需要开发者主动兼容；
3. 3. 广播唤醒有性能开销：调用 broadcast 时，会唤醒所有等待线程，产生一定的调度开销；
4. 4. 超时时间是绝对时间：timedwait 的超时参数是绝对时间，需要通过 clock_gettime 获取当前时间，接口稍复杂；
5. 5. 无法直接传递数据：条件变量只能实现线程的唤醒，无法直接传递数据，数据传递需要依赖共享变量。

✅ 优缺点总结

✔️ 条件变量的优点是压倒性的，是线程同步中最优的条件等待方案，没有任何技术能替代其核心价值；

✔️ 条件变量的缺点都是可规避的，通过规范的代码编写和合理的接口选型，能轻松解决所有局限性；

✔️ 结论：条件变量是 Linux 线程同步的必学、必会、必用的核心技术，没有之一。

全文核心总结（精华提炼，直击本质，背会即用）

1. 1. 条件变量的核心是「等待 + 唤醒」，必须搭配互斥锁使用，互斥锁保资源安全，条件变量控执行顺序；
2. 2. 黄金法则：while(条件)包裹 wait，先加锁再 wait，唤醒必持锁，遵守这三句话，永不踩坑；
3. 3. 核心接口只有 6 个，初始化→等待→唤醒→销毁，逻辑简单，固定范式，极易掌握；
4. 4. 最核心场景是生产者 - 消费者模型，其次是线程启停、初始化屏障、超时等待；
5. 5. 条件变量的优势是极致的 CPU 利用率，缺点是需要兼容虚假唤醒和依赖互斥锁，整体瑕不掩瑜；
6. 6. 生产环境中，优先使用pthread_cond_timedwait和pthread_cond_signal，兼顾安全性和性能。