1405 字
7 分钟
生产者-消费者实验讲稿

生产者-消费者实验讲稿#

对应源码:/home/sanzenin/test/os_1/producer_consumer.cpp 建议录屏时长:4 分钟左右

录屏准备#

先编译程序:

Terminal window
cd /home/sanzenin/test/os_1
cmake -S . -B build
cmake --build build -j

默认运行会一直生产,展示一段后按 Ctrl+C 停止:

Terminal window
./build/producer_consumer

也可以传入任务数量,让程序生产完指定数量后自动结束:

Terminal window
./build/producer_consumer 24

录屏时把终端字号调大一点,保证生产者和三个消费者的输出都能看清。

讲稿正文#

1. 开场#

老师好,这次实验我做的是生产者—消费者问题。程序用 C++17 写,里面有 1 个生产者线程和 3 个消费者线程,它们共用一个消息队列。

生产者每生成一条消息,就把它放进队列;消费者从队列里取消息。队列是共享资源,所以生产和取消息不能同时修改队列。消费者在队列为空的时候要等待,不能一直空转。

2. MessageQueue 的设计#

先看队列。MessageQueue 里用 std::deque<int> 保存任务编号,题目要求队列默认可以存放无限多条消息,所以这里没有设置容量上限。

队列用 std::mutex 保护共享数据,用 std::condition_variable 让消费者在队列为空时等待。stopped_ 表示生产者是否已经结束。这个标志不能省,否则消费者分不清队列为空是因为暂时没有消息,还是因为程序已经结束。

输出部分另外用了一个 output_mutex。终端也是共享资源,多个线程同时输出时,需要保证一行内容不会被另一个线程插进来。

3. 入队函数#

push 的代码是:

void push(int task)
{
{
std::lock_guard<std::mutex> lock(mutex_);
queue_.push_back(task);
}
ready_.notify_one();
}

生产者调用 push 时,lock_guard 只在入队这一段加锁。任务放进队尾后锁马上释放,然后通知一个正在等待的消费者。一次只放入一条消息,所以这里用 notify_one 就够了。

4. 出队函数#

pop 的代码是:

bool pop(int& task)
{
std::unique_lock<std::mutex> lock(mutex_);
ready_.wait(lock, [this] { return stopped_ || !queue_.empty(); });
if (queue_.empty()) {
return false;
}
task = queue_.front();
queue_.pop_front();
return true;
}

这里用 unique_lock,因为 wait 等待时要暂时释放锁,被唤醒后再重新加锁。wait 的条件是队列非空或者已经停止。

醒来后如果队列为空,说明程序已经停止,pop 返回 false,消费者线程结束。否则取出队首任务。取任务的过程一直在锁里,所以三个消费者不会拿到同一条消息。

5. 停止函数#

stop 的代码是:

void stop()
{
{
std::lock_guard<std::mutex> lock(mutex_);
stopped_ = true;
}
ready_.notify_all();
}

这里用 notify_all,因为可能有多个消费者都在等待。生产者结束后,需要把它们全部唤醒,让每个消费者重新检查队列。

6. 生产者循环#

生产者线程是一个 while 循环:

while (keep_running && (total_tasks == 0 || task <= total_tasks)) {
queue.push(task);
printLine("任务 " + std::to_string(task) + " 已生产。");
std::this_thread::sleep_for(std::chrono::milliseconds(150));
++task;
}

total_tasks 为 0 时表示无限生产,按 Ctrl+C 结束;传了任务数量时,循环到指定数量就停止。每生产一条消息等待 150 毫秒,方便观察输出。

7. 消费者循环#

三个消费者线程都执行同一个 while 循环:

while (queue.pop(task)) {
std::this_thread::sleep_for(std::chrono::milliseconds(60));
printLine("消费者 " + std::to_string(id) +
" 取走任务 " + std::to_string(task));
}

取到任务后等待 60 毫秒再打印。哪个消费者拿到哪条任务不是固定的,取决于线程调度。

8. 主线程#

main 里先创建三个消费者线程,再创建生产者线程。消费者启动时队列还是空的,所以会先在条件变量上等待。

生产者结束后,主线程调用 queue.stop(),然后回收三个消费者。消费者会先把队列里剩下的任务处理完,再退出。

程序还注册了 SIGINT 信号处理函数。按 Ctrl+C 时,std::atomic<bool> 类型的 keep_running 被置为 false,生产者循环停止,主线程继续完成收尾。

9. 运行演示#

默认运行:

Terminal window
./build/producer_consumer

终端里会看到类似这样的输出:

程序已启动,按 Ctrl+C 停止。
任务 1 已生产。
消费者 1 取走任务 1
任务 2 已生产。
消费者 2 取走任务 2
任务 3 已生产。
消费者 3 取走任务 3

展示一段时间后按 Ctrl+C,程序会把剩余消息处理完再退出。也可以直接运行 ./build/producer_consumer 24,生产 24 条后自动结束。

10. 结尾#

这个程序的关键在 MessageQueue:deque 负责存消息,mutex 保证互斥,condition_variable 负责等待和唤醒,stopped_ 负责结束。线程函数本身比较简单,只负责生产和消费。

我的讲解结束,谢谢老师。

答辩备用#

为什么消费者不用 while 一直检查队列?

忙等会持续占用 CPU。条件变量让消费者在队列为空时睡眠,收到通知后再检查队列。

为什么 push 用 lock_guard,pop 用 unique_lock?

push 不需要手动释放锁,lock_guard 足够;pop 调用 wait 时需要在等待期间释放锁,所以必须使用 unique_lock。

为什么停止时使用 notify_all?

生产者结束时可能有多个消费者正在等待,notify_all 可以唤醒全部消费者,让它们检查退出条件。

无界队列有什么风险?

如果生产者速度长期快于消费者,队列会持续增长并占用更多内存。实际系统中通常会设置容量上限,并增加队列满时生产者等待的逻辑。

生产者-消费者实验讲稿
https://sanzenin.top/posts/obsidian/生产者-消费者实验讲稿/
作者
Sanzenin 凪
发布于
2026-11-02
许可协议
CC BY-NC-SA 4.0

分享文章

生成精美分享图或复制链接,与更多人分享本文。

继续阅读

沿着主题读

基于共同的标签与分类

换条路线

从其他文章中稳定抽取