C / C++ / 系统课时

用条件变量协调状态变化

用条件变量协调状态变化

互斥量只能保证“同一时刻谁能访问共享状态”,却不能高效表达“状态什么时候变得可用”。本课用有界队列演示 pthread_cond_wait、pthread_cond_signal 与 pthread_cond_broadcast 的正确组合,并用谓词循环抵御虚假唤醒。

学习目标

  • 把条件变量与受同一 mutex 保护的状态谓词绑定使用。
  • 使用 while 循环检查谓词,而不是把一次唤醒当成条件已经成立。
  • 区分 signal 与 broadcast,并在关闭队列时正确唤醒所有等待线程。

条件变量等待的是谓词

条件变量本身不保存“事件已经发生”的状态。真正的条件必须写在共享数据里,例如队列的谓词 count > 0 表示“存在可消费元素”,count < CAPACITY 表示“还有空位”。这些谓词与队列字段必须由同一把 mutex 保护。

pthread_cond_wait(&cond, &mutex) 要求调用线程进入函数前已经持有 mutex。等待过程会原子地释放 mutex 并睡眠;被唤醒后,它会先重新取得 mutex,再返回给调用者。因此,检查谓词和进入等待之间不会留下普通的“先检查、后睡眠”竞态窗口。

条件变量等待与唤醒时序

用有界队列组合 mutex 与条件变量

下面的主示例使用容量为 2 的队列、一个生产者和两个消费者。生产者在队列满时等待 not_full;消费者在队列空且尚未关闭时等待 not_empty。生产结束后设置 closed,并用 pthread_cond_broadcast 唤醒所有可能仍在等待的消费者。

c
#define _POSIX_C_SOURCE 200809L
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

enum { CAPACITY = 2, CONSUMERS = 2, ITEMS = 5 };

struct queue {
    pthread_mutex_t mutex;
    pthread_cond_t not_empty;
    pthread_cond_t not_full;
    int data[CAPACITY];
    int head;
    int tail;
    int count;
    int closed;
    int consumed_sum;
};

static void die_pthread(int rc, const char *what) {
    if (rc != 0) {
        fprintf(stderr, "%s: %s\n", what, strerror(rc));
        exit(EXIT_FAILURE);
    }
}

static void *producer(void *arg) {
    struct queue *q = arg;

    for (int value = 1; value <= ITEMS; ++value) {
        die_pthread(pthread_mutex_lock(&q->mutex), "producer lock");

        while (q->count == CAPACITY) {
            die_pthread(
                pthread_cond_wait(&q->not_full, &q->mutex),
                "producer wait"
            );
        }

        q->data[q->tail] = value;
        q->tail = (q->tail + 1) % CAPACITY;
        q->count++;

        /* 状态已从“可能为空”变为“至少有一个元素”。 */
        die_pthread(pthread_cond_signal(&q->not_empty), "signal not_empty");
        die_pthread(pthread_mutex_unlock(&q->mutex), "producer unlock");
    }

    die_pthread(pthread_mutex_lock(&q->mutex), "producer close lock");
    q->closed = 1;
    die_pthread(
        pthread_cond_broadcast(&q->not_empty),
        "broadcast not_empty"
    );
    die_pthread(pthread_mutex_unlock(&q->mutex), "producer close unlock");
    return NULL;
}

static void *consumer(void *arg) {
    struct queue *q = arg;

    for (;;) {
        die_pthread(pthread_mutex_lock(&q->mutex), "consumer lock");

        while (q->count == 0 && !q->closed) {
            die_pthread(
                pthread_cond_wait(&q->not_empty, &q->mutex),
                "consumer wait"
            );
        }

        if (q->count == 0 && q->closed) {
            die_pthread(pthread_mutex_unlock(&q->mutex), "consumer unlock");
            return NULL;
        }

        int value = q->data[q->head];
        q->head = (q->head + 1) % CAPACITY;
        q->count--;
        q->consumed_sum += value;

        die_pthread(pthread_cond_signal(&q->not_full), "signal not_full");
        die_pthread(pthread_mutex_unlock(&q->mutex), "consumer unlock");
    }
}

int main(void) {
    struct queue q = {
        .mutex = PTHREAD_MUTEX_INITIALIZER,
        .not_empty = PTHREAD_COND_INITIALIZER,
        .not_full = PTHREAD_COND_INITIALIZER
    };
    pthread_t prod;
    pthread_t consumers[CONSUMERS];

    die_pthread(pthread_create(&prod, NULL, producer, &q), "pthread_create");

    for (int i = 0; i < CONSUMERS; ++i) {
        die_pthread(
            pthread_create(&consumers[i], NULL, consumer, &q),
            "pthread_create"
        );
    }

    die_pthread(pthread_join(prod, NULL), "pthread_join");

    for (int i = 0; i < CONSUMERS; ++i) {
        die_pthread(pthread_join(consumers[i], NULL), "pthread_join");
    }

    printf("consumed_sum=%d\n", q.consumed_sum);

    die_pthread(pthread_cond_destroy(&q.not_empty), "destroy not_empty");
    die_pthread(pthread_cond_destroy(&q.not_full), "destroy not_full");
    die_pthread(pthread_mutex_destroy(&q.mutex), "destroy mutex");
    return EXIT_SUCCESS;
}

保存为 condvar_demo.c 后编译并运行:

bash
cc -std=c11 -Wall -Wextra -Wpedantic -pthread condvar_demo.c -o condvar_demo
./condvar_demo

预期输出:

text
consumed_sum=15

两个消费者取得具体元素的先后顺序是不确定的,但 1 到 5 每个值只会被消费一次,所以最终总和应稳定为 15。

为什么必须用 while 检查谓词

不要把等待写成 if (q->count == 0) pthread_cond_wait(...)。POSIX 允许条件等待发生虚假唤醒,而且即使某次唤醒确实来自另一个线程的通知,当前线程重新获得 mutex 之前,其他线程也可能先一步改变共享状态。

因此正确模式始终是“持锁检查谓词,不成立就 wait,返回后再次检查”。对于消费者,本例的谓词不是简单的 count > 0,而是“有数据可取,或者队列已经关闭”;这也是关闭逻辑必须与队列状态一起受 mutex 保护的原因。

选择 signal 还是 broadcast

pthread_cond_signal 至少唤醒一个等待者,适合一次状态变化通常只让一个线程继续的场景。本例每放入一个元素,只需要通知一个消费者;每取走一个元素,也只需要通知一个等待空位的生产者。

pthread_cond_broadcast 会唤醒所有等待者,适合全局状态切换,例如关闭队列、重新配置或阶段结束。生产者把 closed 设为 1 后使用 broadcast,是为了让所有睡在 not_empty 上的消费者都有机会重新检查谓词并退出。

检查条件变量代码的边界

排查条件变量问题时,先确认谓词是否存放在共享状态中并由 mutex 保护,再检查所有 wait 是否位于 while 循环。随后确认修改谓词与发送通知之间不存在无锁竞态,并核对关闭、取消或错误路径是否能唤醒所有可能永久等待的线程。

条件变量解决的不是互斥,而是“状态未满足时如何睡眠等待、满足后如何重新竞争 mutex 并验证状态”。只要始终把 谓词、mutex、条件变量 当成一个整体设计,代码就更容易避免丢失唤醒和虚假唤醒带来的错误。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

用条件变量协调状态变化

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通