C / C++ / 系统课时

实现生产者消费者队列

实现生产者消费者队列

生产者消费者模型的关键不是“把数据放进数组”,而是让多个线程在队列为空或已满时正确等待,并在状态变化后被唤醒。本节用固定容量队列实现一份可运行的 pthread 示例,重点处理互斥访问、条件等待和退出协议。

学习目标

  • 使用互斥锁保护队列的共享状态
  • 用条件变量处理队列为空和已满两种等待条件
  • 理解为什么条件等待必须放在 while 循环中重新检查

队列为什么需要两类条件

固定容量队列同时存在两个互斥条件:消费者只有在“队列非空”时才能取数据,生产者只有在“队列未满”时才能放数据。互斥锁负责让 head、tail 和 count 的修改保持原子性;条件变量则让线程在条件不满足时睡眠,而不是反复轮询占用 CPU。

生产者消费者队列同步关系

pthread_cond_wait 会先原子地释放互斥锁并睡眠,醒来后再重新获得锁。线程被唤醒不代表条件一定成立,因此必须在持锁状态下用 while 再检查条件,不能用一次性的 if。

完整实现

下面使用一个生产者、一个消费者和容量为 4 的环形队列。生产者依次写入 1 到 8,最后写入 -1 作为结束标记;消费者按 FIFO 顺序取出数据。

c
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define CAPACITY 4

typedef struct {
    int data[CAPACITY];
    int head;
    int tail;
    int count;
    pthread_mutex_t mutex;
    pthread_cond_t not_empty;
    pthread_cond_t not_full;
} Queue;

static Queue queue = {
    .head = 0,
    .tail = 0,
    .count = 0,
    .mutex = PTHREAD_MUTEX_INITIALIZER,
    .not_empty = PTHREAD_COND_INITIALIZER,
    .not_full = PTHREAD_COND_INITIALIZER
};

static void queue_push(Queue *q, int value) {
    pthread_mutex_lock(&q->mutex);

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

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

    pthread_cond_signal(&q->not_empty);
    pthread_mutex_unlock(&q->mutex);
}

static int queue_pop(Queue *q) {
    pthread_mutex_lock(&q->mutex);

    while (q->count == 0) {
        pthread_cond_wait(&q->not_empty, &q->mutex);
    }

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

    pthread_cond_signal(&q->not_full);
    pthread_mutex_unlock(&q->mutex);
    return value;
}

static void *producer(void *arg) {
    (void)arg;

    for (int i = 1; i <= 8; i++) {
        queue_push(&queue, i);
    }
    queue_push(&queue, -1);
    return NULL;
}

static void *consumer(void *arg) {
    (void)arg;

    for (;;) {
        int value = queue_pop(&queue);
        if (value == -1) {
            break;
        }
        printf("consume %d\n", value);
    }
    return NULL;
}

int main(void) {
    pthread_t producer_thread;
    pthread_t consumer_thread;
    int rc;

    rc = pthread_create(&consumer_thread, NULL, consumer, NULL);
    if (rc != 0) {
        fprintf(stderr, "pthread_create: %s\n", strerror(rc));
        return EXIT_FAILURE;
    }

    rc = pthread_create(&producer_thread, NULL, producer, NULL);
    if (rc != 0) {
        fprintf(stderr, "pthread_create: %s\n", strerror(rc));
        return EXIT_FAILURE;
    }

    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);
    return EXIT_SUCCESS;
}

预期输出

text
consume 1
consume 2
consume 3
consume 4
consume 5
consume 6
consume 7
consume 8

这个结果说明消费者看到的数据顺序与生产者写入顺序一致。队列何时进入“满”或“空”取决于线程调度,但等待和唤醒逻辑不会改变最终 FIFO 顺序。

编译并运行

在支持 POSIX Threads 的 Linux 环境中保存为 producer_consumer.c,然后编译运行:

bash
gcc -Wall -Wextra -pthread producer_consumer.c -o producer_consumer
./producer_consumer

预期输出

text
consume 1
consume 2
consume 3
consume 4
consume 5
consume 6
consume 7
consume 8

如果编译器或系统路径不同,实际可执行文件位置可能不同。

容易写错的同步细节

不要在未持有 mutex 时读写 count、head 或 tail,否则生产者和消费者可能同时修改队列状态。也不要把 pthread_cond_wait 外层的 while 改成 if:条件变量允许虚假唤醒,而且多个等待线程竞争同一个条件时,先被唤醒的线程也可能先一步改变状态。

pthread_cond_signal 适合每次状态变化只需唤醒一个等待线程的场景;若一次操作可能让多个等待线程都继续执行,可以考虑 pthread_cond_broadcast。无论使用哪一种,真正决定线程能否继续的都应该是受互斥锁保护的条件判断,而不是“收到过一次通知”本身。

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

目录与阅读设置

阅读设置

17

记录一个想法

实现生产者消费者队列

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

登录哪都通