C / C++ / 系统课时

生产者消费者怎么落到代码里

生产者消费者怎么落到代码里

生产者消费者真正落到代码时,难点不在启动两个线程,而在同时处理队列为空、队列已满以及程序准备退出这三种等待条件。本节实现一个可关闭的有界队列,让生产者不会无限写入,消费者不会空转,并保证关闭时没有线程永久卡在条件变量上。

学习目标

  • 用互斥量和条件变量实现线程安全的有界队列
  • 正确处理队列满、队列空以及关闭状态
  • 理解生产者和消费者分别应该通知哪个等待条件

把等待条件拆成队列非空和队列未满

有界队列至少包含容量、元素容器和关闭标志三个共享状态。生产者只有在“队列未满且尚未关闭”时才能写入;消费者只有在“队列非空”时才能读取,而关闭后如果队列已经排空,则应该结束消费。

使用两个条件变量可以把两类等待关系分开:not_full 只服务等待空间的生产者,not_empty 只服务等待数据的消费者。这样每次状态变化都能通知真正可能取得进展的一侧。

有界生产者消费者队列的数据流与等待条件

实现一个可关闭的有界队列

下面的 BoundedQueue 使用 std::deque 保存元素。push 在队列满时等待,pop 在队列空时等待;close 修改关闭状态后唤醒两边所有等待者,使它们重新检查退出条件。

cpp
#include <condition_variable>
#include <cstddef>
#include <deque>
#include <iostream>
#include <mutex>
#include <thread>

class BoundedQueue {
public:
    explicit BoundedQueue(std::size_t capacity) : capacity_(capacity) {}

    bool push(int value) {
        std::unique_lock<std::mutex> lock(mutex_);
        not_full_.wait(lock, [&] {
            return queue_.size() < capacity_ || closed_;
        });

        if (closed_) {
            return false;
        }

        queue_.push_back(value);
        lock.unlock();
        not_empty_.notify_one();
        return true;
    }

    bool pop(int& value) {
        std::unique_lock<std::mutex> lock(mutex_);
        not_empty_.wait(lock, [&] {
            return !queue_.empty() || closed_;
        });

        // 关闭后仍允许把队列中的剩余元素消费完。
        if (queue_.empty()) {
            return false;
        }

        value = queue_.front();
        queue_.pop_front();
        lock.unlock();
        not_full_.notify_one();
        return true;
    }

    void close() {
        {
            std::lock_guard<std::mutex> lock(mutex_);
            closed_ = true;
        }
        // 所有等待者都必须重新检查关闭条件,否则可能永久等待。
        not_empty_.notify_all();
        not_full_.notify_all();
    }

private:
    std::size_t capacity_;
    std::deque<int> queue_;
    bool closed_ = false;
    std::mutex mutex_;
    std::condition_variable not_empty_;
    std::condition_variable not_full_;
};

int main() {
    BoundedQueue queue(2);

    std::thread producer([&] {
        for (int value = 1; value <= 5; ++value) {
            if (!queue.push(value)) {
                return;
            }
        }
        queue.close();
    });

    std::thread consumer([&] {
        int sum = 0;
        int value = 0;
        while (queue.pop(value)) {
            sum += value;
        }
        std::cout << "sum=" << sum << std::endl;
    });

    producer.join();
    consumer.join();
}

预期输出

text
sum=15

队列容量只有 2,但生产者最终仍能写入五个值,因为消费者每取走一个元素都会释放一个槽位。生产完成后调用 close();消费者继续取完剩余元素,直到发现“队列为空且已经关闭”才结束。

为什么通知要放在状态变化之后

生产者执行 push_back 后,队列从空变成非空的可能性出现,因此通知 not_empty。消费者执行 pop_front 后,队列从满变成未满的可能性出现,因此通知 not_full。如果在修改状态之前通知,等待线程即使先醒来也可能仍看到旧状态,只能再次等待。

示例在修改队列后主动 unlock(),再调用 notify_one()。这样被唤醒的一方可以立即竞争已经释放的互斥锁。把通知放在锁内通常也能保证正确性,但可能增加一次无意义的锁等待。

这里使用带谓词的 wait,因此即使发生虚假唤醒,线程仍会重新检查队列状态,不会直接访问空队列或向满队列继续写入。

关闭状态是避免永久等待的关键

如果生产者只是停止运行,却没有改变任何消费者可观察的共享状态,那么一个正等待 not_empty 的消费者无法知道“以后再也不会有数据”,它可能永久阻塞。关闭标志就是把生命周期信息纳入同步协议。

close() 使用 notify_all() 而不是 notify_one(),因为关闭属于全局状态变化:所有生产者和消费者都需要重新判断自己是否应该退出。对于普通的单次入队和出队,则只释放一个新的消费机会或一个新的生产槽位,因此 notify_one() 更匹配状态变化。

扩展到多个生产者和消费者

这个实现已经能够被多个生产者和消费者共同调用,因为队列、关闭标志以及容量判断都由同一把互斥锁保护。每次只在持锁期间检查或修改共享状态,真正耗时的业务处理应放在 pop 返回之后执行,避免把队列锁变成整个任务处理链路的串行瓶颈。

当业务还需要超时取消、错误传播或优先级时,可以继续扩展等待谓词,但基本原则不变:把线程能否继续执行的事实放进共享状态,把条件变量只当作“状态可能变化”的唤醒机制。

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

目录与阅读设置

阅读设置

17

记录一个想法

生产者消费者怎么落到代码里

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

登录哪都通