用多线程同步方法解决生产者-消费者问题操作系统课设

合集下载

生产者消费者程序设计

生产者消费者程序设计在计算机科学中，生产者消费者问题是一个经典的多线程同步问题，它反映了在并发环境中生产者和消费者之间的协作关系。

这个问题不仅在理论上具有重要意义，而且在实际的软件开发中也有广泛的应用。

让我们先来理解一下什么是生产者和消费者。

简单来说，生产者就是负责生产数据或产品的部分，而消费者则是使用或消耗这些数据或产品的部分。

想象一个面包店的场景。

面包师傅（生产者）不断地制作面包，然后将它们放在货架上。

顾客（消费者）则从货架上购买并享用这些面包。

在这个过程中，如果面包师傅制作面包的速度太快，货架放不下，就会出现问题；如果制作速度太慢，顾客可能会等得不耐烦。

同样，如果顾客购买面包的速度太快，面包师傅来不及制作，顾客会感到不满；如果购买速度太慢，面包可能会过期。

在程序设计中，我们要解决的就是如何让生产者和消费者能够高效、协调地工作，避免出现上述的问题。

为了实现生产者消费者的有效协作，我们通常会使用一些同步机制。

其中，最常见的就是使用缓冲区。

缓冲区就像是面包店中的货架，生产者将生产出来的数据放入缓冲区，消费者从缓冲区中取出数据进行处理。

在实现生产者消费者程序时，我们需要考虑几个关键的要点。

首先是线程安全。

由于生产者和消费者是在不同的线程中运行的，可能会同时访问缓冲区，这就可能导致数据不一致或者竞争条件等问题。

为了解决这个问题，我们通常会使用锁或者信号量等机制来保证线程安全。

例如，我们可以使用一个互斥锁来保护缓冲区的访问。

当生产者想要向缓冲区中添加数据时，它首先需要获取锁，添加完成后释放锁。

消费者在从缓冲区中取出数据时，也需要先获取锁，取出后释放锁。

这样就可以确保在同一时间只有一个线程能够访问缓冲区，避免了数据冲突。

其次是缓冲区的设计。

缓冲区的大小是一个需要仔细考虑的因素。

如果缓冲区太小，生产者可能会经常因为缓冲区已满而等待；如果缓冲区太大，会浪费内存资源。

一般来说，缓冲区的大小需要根据生产者和消费者的生产和消费速度来确定。

C++11并发指南九（综合运用：C++11多线程下生产者消费者模型详解）

C++11并发指南九（综合运⽤：C++11多线程下⽣产者消费者模型详解）前⾯⼋章介绍了 C++11 并发编程的基础(抱歉哈，第五章-第⼋章还在草稿中)，本⽂将综合运⽤ C++11 中的新的基础设施(主要是多线程、锁、条件变量)来阐述⼀个经典问题——，并给出完整的解决⽅案。

⽣产者消费者问题是多线程并发中⼀个⾮常经典的问题，相信学过操作系统课程的同学都清楚这个问题的根源。

本⽂将就四种情况分析并介绍⽣产者和消费者问题，它们分别是：单⽣产者-单消费者模型，单⽣产者-多消费者模型，多⽣产者-单消费者模型，多⽣产者-多消费者模型，我会给出四种情况下的 C++11 并发解决⽅案，如果⽂中出现了错误或者你对代码有异议，欢迎交流 ;-)。

单⽣产者-单消费者模型顾名思义，单⽣产者-单消费者模型中只有⼀个⽣产者和⼀个消费者，⽣产者不停地往产品库中放⼊产品，消费者则从产品库中取⾛产品，产品库容积有限制，只能容纳⼀定数⽬的产品，如果⽣产者⽣产产品的速度过快，则需要等待消费者取⾛产品之后，产品库不为空才能继续往产品库中放置新的产品，相反，如果消费者取⾛产品的速度过快，则可能⾯临产品库中没有产品可使⽤的情况，此时需要等待⽣产者放⼊⼀个产品后，消费者才能继续⼯作。

C++11实现单⽣产者单消费者模型的代码如下：#include <unistd.h>#include <cstdlib>#include <condition_variable>#include <iostream>#include <mutex>#include <thread>static const int kItemRepositorySize = 10; // Item buffer size.static const int kItemsToProduce = 1000; // How many items we plan to produce.struct ItemRepository {int item_buffer[kItemRepositorySize]; // 产品缓冲区, 配合 read_position 和 write_position 模型环形队列.size_t read_position; // 消费者读取产品位置.size_t write_position; // ⽣产者写⼊产品位置.std::mutex mtx; // 互斥量,保护产品缓冲区std::condition_variable repo_not_full; // 条件变量, 指⽰产品缓冲区不为满.std::condition_variable repo_not_empty; // 条件变量, 指⽰产品缓冲区不为空.} gItemRepository; // 产品库全局变量, ⽣产者和消费者操作该变量.typedef struct ItemRepository ItemRepository;void ProduceItem(ItemRepository *ir, int item){std::unique_lock<std::mutex> lock(ir->mtx);while(((ir->write_position + 1) % kItemRepositorySize)== ir->read_position) { // item buffer is full, just wait here.std::cout << "Producer is waiting for an empty slot...\n";(ir->repo_not_full).wait(lock); // ⽣产者等待"产品库缓冲区不为满"这⼀条件发⽣.}(ir->item_buffer)[ir->write_position] = item; // 写⼊产品.(ir->write_position)++; // 写⼊位置后移.if (ir->write_position == kItemRepositorySize) // 写⼊位置若是在队列最后则重新设置为初始位置.ir->write_position = 0;(ir->repo_not_empty).notify_all(); // 通知消费者产品库不为空.lock.unlock(); // 解锁.}int ConsumeItem(ItemRepository *ir){int data;std::unique_lock<std::mutex> lock(ir->mtx);// item buffer is empty, just wait here.while(ir->write_position == ir->read_position) {std::cout << "Consumer is waiting for items...\n";(ir->repo_not_empty).wait(lock); // 消费者等待"产品库缓冲区不为空"这⼀条件发⽣.}data = (ir->item_buffer)[ir->read_position]; // 读取某⼀产品(ir->read_position)++; // 读取位置后移if (ir->read_position >= kItemRepositorySize) // 读取位置若移到最后，则重新置位.ir->read_position = 0;(ir->repo_not_full).notify_all(); // 通知消费者产品库不为满.lock.unlock(); // 解锁.return data; // 返回产品.}void ProducerTask() // ⽣产者任务{for (int i = 1; i <= kItemsToProduce; ++i) {// sleep(1);std::cout << "Produce the " << i << "^th item..." << std::endl;ProduceItem(&gItemRepository, i); // 循环⽣产 kItemsToProduce 个产品.}}void ConsumerTask() // 消费者任务{static int cnt = 0;while(1) {sleep(1);int item = ConsumeItem(&gItemRepository); // 消费⼀个产品.std::cout << "Consume the " << item << "^th item" << std::endl;if (++cnt == kItemsToProduce) break; // 如果产品消费个数为 kItemsToProduce, 则退出.}}void InitItemRepository(ItemRepository *ir){ir->write_position = 0; // 初始化产品写⼊位置.ir->read_position = 0; // 初始化产品读取位置.}int main(){InitItemRepository(&gItemRepository);std::thread producer(ProducerTask); // 创建⽣产者线程.std::thread consumer(ConsumerTask); // 创建消费之线程.producer.join();consumer.join();}单⽣产者-多消费者模型与单⽣产者和单消费者模型不同的是，单⽣产者-多消费者模型中可以允许多个消费者同时从产品库中取⾛产品。

操作系统课程设计——生产者消费者问题

计算机与信息学院《操作系统与编译原理联合课程设计报告》专题：操作系统部分学生姓名：学号：专业班级：指导教师：2014 年 7 月一、设计目标多进程/线程编程：生产者-消费者问题。

设置两类进程/线程，一类为生产者，一类为消费者；建立缓冲区的数据结构；随机启动生产者或消费者；显示缓冲区状况；随着进程/线程每次操作缓冲区，更新显示。

二、设计思路1.开发平台：Visual C++6.02.设计思路：若干个生产者和若干个消费者共享一个有界缓冲区，生产者生产产品，消费者消费产品。

消费者进程与生产者进程随机切换。

生产者将产品生产出来后，存放到缓冲区中的空闲位置并将此缓冲区的标识置为满，若此时无空缓冲区，则进行等待。

消费者将标识为满的缓冲区中的产品取出，进行消费并将该缓冲区的标志位置为空，若此时无满的缓冲区，则进行等待。

由于消费者与生产者共享缓冲区资源，且缓冲区资源属于互斥资源，所以生产者和消费者需要按照一定的规则访问缓冲区，访问规则如下：（1）当一个消费者访问缓冲区时其他消费者不允许访问缓冲区，同样的，当一个生产者访问缓冲区时其他生产者也不能访问缓冲区。

（2）当消费者访问缓冲区资源时生产者不能访问，反之，当生产者访问缓冲区资源时消费者不能访问。

（3）当缓冲区中无产品时，消费者不能访问；当缓冲区已满时，生产者不能访问缓冲区。

生产者与消费者问题伪代码如下：VAR mutex, empty, full: semaphore := 1, n, 0 ;in,out: integer := 0, 0 ;Buffer: array [0..n-1] of item ;ParbeginProducer:beginrepeatproduce an item in nextp;wait(empty);wait(mutex);Buffer(in) := nextp;in := (in + 1) mod n;signal(mutex);signal(full);until falseendConsumer:beginrepeatwait(full);wait(mutex);nextc = Buffer(out);out := (out + 1) mod n;signal(mutex);signal(empty);consume the item nextc;until falseendParend程序框架如下图所示：本程序在具体实现方面与MFC结合，将生产者-消费者问题的具体过程动态展示了出来。

【实验】java多线程实验报告

【关键字】实验java多线程实验报告篇一：西北农林科技大学java多线程实验报告实验7 多线程1.实验目的(1) 掌握Java多线程的概念和实现方法(2) 掌握Java多线程的同步问题2.实验内容任务一：火车售票假设有火车票1000张，创建10个线程模拟10个售票点，每个售票点100毫秒买一张票。

打印出售票过程，注意使用synchronized确保同一张票只能卖出一次。

程序运行结果见左图。

打开EclipseTickets.javapublic class Ticket extends Thread {int ticket =1000; String name =""; public void run(){ while(true){synchronized(name){ if(ticket"第" + Thread.currentThread().getName()+ "售票点卖出了第" + ticket-- + "张票");}} }}} try{ } catch(InterruptedException e){ } Thread.sleep(100);Test.javapublic class Test {} public static void main(String args[]){} Ticket t = new Ticket(); new Thread(t,"1").start(); new Thread(t,"2").start(); new Thread(t,"3").start(); new Thread(t,"4").start(); new Thread(t,"5").start(); new Thread(t,"6").start(); new Thread(t,"7").start(); new Thread(t,"8").start(); new Thread(t,"9").start(); new Thread(t,"10").start();任务二：银行存款假设某家银行，它可接受顾客的汇款，每做一次汇款，便可计算出汇款的总额。

操作系统中的经典问题——生产者消费者问题（两种方式实现）

操作系统中的经典问题——⽣产者消费者问题（两种⽅式实现）操作系统中的经典问题——⽣产者消费者问题（两种⽅式实现）1、问题引⼊：什么是⽣产者消费者问题？⽣产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是⼀个多线程同步问题的经典案例。

该问题描述了共享固定⼤⼩缓冲区的两个线程——即所谓的“⽣产者”和“消费者”——在实际运⾏时会发⽣的问题。

⽣产者的主要作⽤是⽣成⼀定量的数据放到缓冲区中，然后重复此过程。

与此同时，消费者也在缓冲区消耗这些数据。

该问题的关键就是要保证⽣产者不会在缓冲区满时加⼊数据，消费者也不会在缓冲区中空时消耗数据。

.要解决该问题，就必须让⽣产者在缓冲区满时休眠（要么⼲脆就放弃数据），等到下次消费者消耗缓冲区中的数据的时候，⽣产者才能被唤醒，开始往缓冲区添加数据。

同样，也可以让消费者在缓冲区空时进⼊休眠，等到⽣产者往缓冲区添加数据之后，再唤醒消费者。

通常采⽤进程间通信的⽅法解决该问题。

如果解决⽅法不够完善，则容易出现死锁的情况。

出现死锁时，两个线程都会陷⼊休眠，等待对⽅唤醒⾃⼰。

该问题也能被推⼴到多个⽣产者和消费者的情形。

2、问题分析该问题需要注意的⼏点：1. 在缓冲区为空时，消费者不能再进⾏消费2. 在缓冲区为满时，⽣产者不能再进⾏⽣产3. 在⼀个线程进⾏⽣产或消费时，其余线程不能再进⾏⽣产或消费等操作，即保持线程间的同步4. 注意条件变量与互斥锁的顺序由于前两点原因，因此需要保持线程间的同步，即⼀个线程消费（或⽣产）完，其他线程才能进⾏竞争CPU，获得消费（或⽣产）的机会。

对于这⼀点，可以使⽤条件变量进⾏线程间的同步：⽣产者线程在product之前，需要wait直⾄获取⾃⼰所需的信号量之后，才会进⾏product的操作；同样，对于消费者线程，在consume之前需要wait直到没有线程在访问共享区（缓冲区），再进⾏consume的操作，之后再解锁并唤醒其他可⽤阻塞线程。

操作系统实验——PV操作实现生产者消费者模型

2. 生产者类
/** * 单个生产者类 * @author Vfdxvffd * @count 生产的物品数量标号 */ class Producer implements Runnable{ int count = 0; //数量 @Override public void run() { while(count < 20) { //最多生产20件商品
Global.empty.Wait(); /*要生产物品了，给剩余空闲缓冲区数量--，如果减完后变为负数，则说明当前没有空闲缓冲区，则加入等待队列*/ //临界区，生产商品 int index = count % 2; Global.buffer[index] = count; System.out.println("生产者在缓冲区"+index+"中生产了物品"+count); count++;
假如生产者号生产了0号商品，但此时他还没做Global.pCount++这一步操作，CPU将执行权切换到生产者2号，这时Global.pCount的值还是刚刚的0，没有加1，所以又会生产出一个0号商品，那消费者也同理，消费完还没加1，就被切换了执行权。
那就有个问题，如果我们将Global.pCount++这一步提前能不能解决问题呢，当然也是不行的，因为可能++完还没输出就被切换执行权，那下次执行权回来时候就会继续执行输出操作，但此时的Global.pCount的值已经不知道加了多少了。
/*remove a process P from the waiting queue*/ wakeup(P); } }
信号量的应用

利用JAVA多线程并发机制解决生产者—消费者问题

ＣｈｎＹｌｅ
ＡｂｔａｔＴｅｐｐｒａａｙｅｄｄｓｒｂｓｔｅｃｍｐｉａｅｒｃｓｆｍｕｔｔｅｄｄＪｓｒｃ：ｈａｅｎｌｚｓａｅｃｉｅｈｏｌｔｄｐｏｅｓｏｌｉｈｒａｅＡＶＡｙｃｒｎｚｔｎｍｅｈｎｓａｄｎｃ — ｓｎｈｏｉａｉｃａｉｍｎｏ
２１车２月Ｏ０
电脑学习
第１期
利用ＪＶ多线程并发机制解决生产者一消费者问题ＡＡ
陈益
摘要：本文分析并描述了ＪＶＡＡ多线程并发过程中的同步机制及消息通信机制的基本原理．探讨如何运用多线程同步机制
和消息互通机制切实解决生产者和消费者之间的问题。
Ｔｒａｈｄ类提供了各种与线程有关的方法，方便．本文将采用继承Ｔｒａ来实现多ｈｄ类ｅ
线程技术。但是在程序中，所有线程共享同一内存空间，两个或多个线程可能同时访问同一变量或运行同一对象的同
Ｊｖａａ语言和Ｊｖ虚拟机提供了完全意义上的多线程支ａａ持，其内置语言级的多线程机制让用户更方便地实现多个并行程序的开发，从语言级上提供各个线程问协调工作的调度能力，降低并发程序设计的难度。在Ｊｖａａ中，多线程的
建立有两种方法：继承Ｔｒａｈｅｄ类和实现Ｒｎａｌ口。ｕｎｂｅ接
ｔｅｂｓｃｐｉｃｐｅｆｍｅｓｇｏｈａｉｒｎｉｌｓｏｓａｅｃｍｍｕｃｔｏｃａｉｍ，ｘｌｒｈｏｕｅｍｕｔｔｒａｙｃｒｎｚｔｏｌｈ－ｉｎａｉｎｍｅｈｓｅｐｏ￣ｎｗｏｔｓｌｉｈｅｄｓｈｏａｉｎｌ－ｎｉ￣ｃａｉｍｎｓａｄｍｅｓｇｘｈｎｅｍｅｈｎｓｔａｕｄｅｅｔｅｙｓｌｅｔｅｐｂｅｅｗｅｎｐｏｕｅｓａｏｓｍｅｓｎｓａｅｅｃａｇｃａｉｍｈｔｗｏｌｆｃｉｌｏｖｈｒｌｍｓｂｔｅｒｄｃｒｎｄｃｎｕｒ．ｖｏｌｉｔｒａｅＫｅｗｏｄＭｕｔ－ｈｅｄｄｙｒ：ＳｎｈｏｉａｉｎｙｃｒｎｚｔｏＣｎｔｏｃｍ￣ｎｅｃＰｏｕｅｒｄｃｒＣｎｕｒｏｓｍｅ

操作系统课程设计“生产者-消费者”问题

《操作系统》课程设计题目：“生产者-消费者”问题学院：信息工程学院专业：计算机科学与技术班级：计科1302*名：***指导老师：***2016年1月 15日目录一、课程设计目标 (2)二、课题内容 (2)1．实验目的 (2)2、实验环境 (2)3、实验要求 (2)三、设计思路 (3)1.信号量的设置 (3)2.系统结构 (4)3.程序流程图 (5)4.P V操作代码 (6)四、源代码 (7)五、运行与测试 (10)六、心得体会 (12)一、课程设计目标学习System V的进程间通信机制，使用信号量和共享内存实现经典进程同步问题“生产者-消费者”问题。

具体要求：1.创建信号量集，实现同步互斥信号量。

2.创建共享内存，模拟存放产品的公共缓冲池。

3.创建并发进程，实现进程对共享缓冲池的并发操作。

二、课题内容1．实验目的（1）掌握基本的同步互斥算法，理解生产者和消费者同步的问题模型。

（2）了解linux中多线程的并发执行机制，线程间的同步和互斥。

2、实验环境：C/C++语言编译器3、实验要求（1）创建生产者和消费者线程在linux环境下，创建一个控制台进程，在此进程中创建n个线程来模拟生产者或者消费者。

这些线程的信息由本程序定义的“测试用例文件”中予以指定。

（2）生产和消费的规则在按照上述要求创建线程进行相应的读写操作时，还需要符合以下要求：①共享缓冲区存在空闲空间时，生产者即可使用共享缓冲区。

②从上边的测试数据文件例子可以看出，某一生产者生产一个产品后，可能不止一个消费者，或者一个消费者多次地请求消费该产品。

此时，只有当所有的消费需求都被满足以后，该产品所在的共享缓冲区才可以被释放，并作为空闲空间允许新的生产者使用。

③每个消费者线程的各个消费需求之间存在先后顺序。

例上述测试用例文件包含一行信息“5 C 3 l 2 4”，可知这代表一个消费者线程，该线程请求消费1，2，4号生产者线程生产的产品。

而这种消费是有严格顺序的，消费1号线程产品的请求得到满足后才能继续往下请求2号生产者线程的产品。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

学号：课程设计题目用多线程同步方法解决生产者－消费者问题(Producer-Consumer Problem)学院计算机科学与技术学院专业软件工程班级姓名指导教师年月日目录目录 (1)课程设计任务书 (1)正文 (2)1.设计目的与要求 (2)1.1设计目的 (2)1.2设计要求 (2)2.设计思想及系统平台 (2)2.1设计思想 (2)2.2系统平台及使用语言 (2)3.详细算法描述 (3)4.源程序清单 (5)5.运行结果与运行情况 (10)6.调试过程 (13)7.总结 (13)本科生课程设计成绩评定表 ..................................................... 错误！未定义书签。

课程设计任务书学生姓名：专业班级：指导教师：工作单位：计算机科学与技术学院题目: 用多线程同步方法解决生产者－消费者问题(Producer-Consumer Problem)初始条件：1．操作系统：Linux2．程序设计语言：C语言3．有界缓冲区内设有20个存储单元，其初值为0。

放入／取出的数据项按增序设定为1－20这20个整型数。

要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．技术要求：1）为每个生产者／消费者产生一个线程，设计正确的同步算法2）每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的当前全部内容、当前指针位置和生产者／消费者线程的自定义标识符。

3）生产者和消费者各有两个以上。

4）多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。

2．设计说明书内容要求：1)设计题目与要求2)总的设计思想及系统平台、语言、工具等。

3）数据结构与模块说明（功能与流程图）4）给出用户名、源程序名、目标程序名和源程序及其运行结果。

（要注明存储各个程序及其运行结果的主机IP地址和目录。

）5）运行结果与运行情况（提示: （1）有界缓冲区可用数组实现。

（2）编译命令可用：cc -lpthread -o 目标文件名源文件名（3）多线程编程方法参见附件。

）3. 调试报告：1)调试记录2)自我评析和总结上机时间安排：18周一~ 五 08：0 － 12：00指导教师签名：年月日系主任（或责任教师）签名：年月日正文1.设计目的与要求1.1设计目的通过研究Linux的线程机制和信号量实现生产者消费者问题(Producer-Consumer Problem)的并发控制。

1.2设计要求1）为每个生产者／消费者产生一个线程，设计正确的同步算法2）每个生产者/消费者对该存储区进行操作后，即时显示该存储区的全部内容、当前指针位置和生产者/消费者线程的自定义标识符。

3）生产者和消费者各有两个以上。

4）多个生产者/消费者之间须共享对存储区进行操作的函数代码。

2.设计思想及系统平台2.1设计思想在本问题中,共需要一个Mutex和两个Semaphore.其中,Mutex是用来锁定临界区的,以解决对共享数据buffer的互斥访问问题(无论是对生成者还是对消费者);我们共需要两个Semaphore,这是因为在本问题中共有两个稀缺资源.第一种是"非空"这种资源,是在消费者之间进行竞争的.第二种是"非满"这种资源,是在生产者之间进行竞争的.所以,一般来说,需要锁定临界区,就需要Mutex;有几种稀缺资源就需要几个Semaphore.对稀缺资源的分析不能想当然.稀缺资源不一定是指被共享的资源,很多时候是指线程会被阻塞的条件(除了要进临界区被阻塞外).在生产者消费者问题中,消费者会在缓冲区为空时被阻塞,所以"非空"是一种稀缺资源;需要设置一个信号量consumer_semaphore,初值设为0;生产者会在缓冲区为满时被阻塞,所以"非满"也是一种稀缺资源.需要设置一个信号量producer_semaphore,初值设为buffer的大小MAX_BUFFER2.2系统平台及使用语言本课程设计在Linux操作系统下，使用C语言完成。

用到的工具主要有GCC编译器和VI编辑器。

3.详细算法描述共享数据：Semaphore buffer_mutex=1；Semaphore producer_semaphore=MAX_BUFFER；Semaphore consumer_semaphore=0；int buffer[MAX_BUFFER];Producer线程的处理函数：while(1){Wait(producer_semaphore);Wait(buffer_mutex);Buffer[pn]=product;pn=(pn+1)%MAX_BUFFER;Signal(consumer_semaphore);Signal(buffer_mutex);Sleep();}producer线程的处理函数流程图如下：consumer线程的处理函数:while(1){Wait(consumer_semaphore);Wait(buffer_mutex);Consume=buffer[cn];cn=(cn+1)%MAX_BUFFER;Signal(producer_semaphore);Signal(buffer_mutex);Sleep();}consumer线程的处理函数流程图如下：4.源程序清单用户名：rj070126（IP：192.168.2.254）源程序名：/home/rj070126/pc.c目标程序名：/home/rj070126/pc运行结果：/home/rj070126/output.txt源程序清单如下：#include<stdio.h>#include<stdlib.h>#include<string.h>#include<pthread.h>#include<semaphore.h>#include<sys/types.h>#include<errno.h>#include<unistd.h>#include<signal.h>#include<time.h>#define NUM_THREADS_P 5 /*define the number of producer*/ #define NUM_THREADS_C 5 /*define the number of consumer*/ #define MAX_BUFFER 20 /*define the number of buffer*/#define RUN_TIME 20 /*define the run time*/int buffer[MAX_BUFFER]; /*difine the buffer */int produce_pointer=0,consume_pointer=0;sem_t producer_semaphore,consumer_semaphore,buffer_mutex; pthread_t threads_p[NUM_THREADS_P]; /*producer*/pthread_t threads_c[NUM_THREADS_C]; /*consumer*/FILE* fd;void *producer_thread(void *tid);void *consumer_thread(void *tid);void showbuf();void handler(){int i;for(i=0;i<NUM_THREADS_P;i++)pthread_cancel(threads_p[i]);for(i=0;i<NUM_THREADS_C;i++)pthread_cancel(threads_c[i]);}int main(){int i;signal(SIGALRM,handler);fd=fopen("output.txt","w"); /*open a file to save the result*/sem_init(&producer_semaphore,0,MAX_BUFFER); /*set the value of semaphores*/ sem_init(&consumer_semaphore,0,0);sem_init(&buffer_mutex,0,1);for(i=0;i<MAX_BUFFER;i++)buffer[i]=0; /*initiate the buffer*//*create the threads*/for(i=0;i<NUM_THREADS_P;i++)pthread_create(&threads_p[i],NULL,(void*)producer_thread,(void*)(i+1));for(i=0;i<NUM_THREADS_C;i++)pthread_create(&threads_c[i],NULL,(void*)consumer_thread,(void *)(i+1));alarm(RUN_TIME); /*set time to run*//*wait the threads to exit*/for(i=0;i<NUM_THREADS_P;i++)pthread_join(threads_p[i],NULL);for(i=0;i<NUM_THREADS_C;i++)pthread_join(threads_c[i],NULL);/*destroy the semaphores*/sem_destroy(&producer_semaphore);sem_destroy(&consumer_semaphore);sem_destroy(&buffer_mutex);fclose(fd);return 0;}void *producer_thread(void *tid){/*the thread can be canceled by other thread*/pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);while(1){sem_wait(&producer_semaphore);srand((int)time(NULL)*(int)tid);sleep(rand()%2+1); /*one or two seconds to produce*/while((produce_pointer+1)%20==consume_pointer);sem_wait(&buffer_mutex);buffer[produce_pointer]=rand()%20+1;produce_pointer=(produce_pointer+1)%20;if(produce_pointer==0){ /*if buffer was filled to the 19th*/printf("producer:%d pointer_p:%2d produced:%2d\n",(int)tid,19,buffer[19]);fprintf(fd,"producer:%d pointer_p:%2d produced:%2d\n",(int)tid,19,buffer[19]);}else{printf("producer:%d pointer_p:%2d produced:%2d\n",(int)tid,produce_pointer-1,buffer[produce_pointer-1]);fprintf(fd,"producer:%d pointer_p:%2d produced:%2d\n",(int)tid,produce_pointer-1,buffer[produce_pointer-1]);}showbuf();sem_post(&buffer_mutex);sem_post(&consumer_semaphore); /*inform the consumer the buffer is not empty*/srand((int)time(NULL)*(int)tid);sleep(rand()%5+1); /*wait a few seconds ,then continue producing*/ }return ((void*)0);}void *consumer_thread(void *tid){/*the thread can be canceled by other thread*/pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);while(1){sem_wait(&consumer_semaphore);srand((int)time(NULL)*(int)tid);sleep(rand()%2+1); /*one or two seconds to consume*/sem_wait(&buffer_mutex);printf("consumer:%d pointer_c:%2d consumed:%2d\n",(int)tid,consume_pointer,buffer[consume_pointer]);fprintf(fd,"consumer:%d pointer_c:%2d consumed:%2d\n",(int)tid,consume_pointer,buffer[consume_pointer]);buffer[consume_pointer]=0;consume_pointer=(consume_pointer+1)%20;showbuf();sem_post(&buffer_mutex);sem_post(&producer_semaphore);srand((int)time(NULL)*(int)tid);sleep(rand()%5+1); /*wait a few seconds ,then continue consuming*/ }return ((void*)0);}/*show the content of buffer*/void showbuf(){int i;printf("buffer:");fprintf(fd,"buffer:");for(i=0;i<MAX_BUFFER;i++){printf("%2d ",buffer[i]);fprintf(fd,"%2d ",buffer[i]);}printf("\n\n");fprintf(fd,"\n\n");}5.运行结果与运行情况程序运行结果如下：producer:1 pointer_p: 0 produced:20buffer:20 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 producer:3 pointer_p: 1 produced:13buffer:20 13 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 producer:2 pointer_p: 2 produced: 6buffer:20 13 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 producer:4 pointer_p: 3 produced:14buffer:20 13 6 14 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 producer:5 pointer_p: 4 produced:20buffer:20 13 6 14 20 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 consumer:2 pointer_c: 0 consumed:20buffer: 0 13 6 14 20 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 producer:1 pointer_p: 5 produced:20buffer: 0 13 6 14 20 20 0 0 0 0 0 0 0 0 0 0 0 0 0 0 consumer:1 pointer_c: 1 consumed:13buffer: 0 0 6 14 20 20 0 0 0 0 0 0 0 0 0 0 0 0 0 0 consumer:3 pointer_c: 2 consumed: 6buffer: 0 0 0 14 20 20 0 0 0 0 0 0 0 0 0 0 0 0 0 0 consumer:4 pointer_c: 3 consumed:14buffer: 0 0 0 0 20 20 0 0 0 0 0 0 0 0 0 0 0 0 0 0 consumer:5 pointer_c: 4 consumed:20buffer: 0 0 0 0 0 20 0 0 0 0 0 0 0 0 0 0 0 0 0 0 producer:3 pointer_p: 6 produced: 1buffer: 0 0 0 0 0 20 1 0 0 0 0 0 0 0 0 0 0 0 0 0 producer:2 pointer_p: 7 produced:14buffer: 0 0 0 0 0 20 1 14 0 0 0 0 0 0 0 0 0 0 0 0 consumer:3 pointer_c: 5 consumed:20buffer: 0 0 0 0 0 0 1 14 0 0 0 0 0 0 0 0 0 0 0 0 producer:4 pointer_p: 8 produced: 6buffer: 0 0 0 0 0 0 1 14 6 0 0 0 0 0 0 0 0 0 0 0 consumer:5 pointer_c: 6 consumed: 1buffer: 0 0 0 0 0 0 0 14 6 0 0 0 0 0 0 0 0 0 0 0 producer:5 pointer_p: 9 produced: 8buffer: 0 0 0 0 0 0 0 14 6 8 0 0 0 0 0 0 0 0 0 0 consumer:2 pointer_c: 7 consumed:14buffer: 0 0 0 0 0 0 0 0 6 8 0 0 0 0 0 0 0 0 0 0 consumer:5 pointer_c: 8 consumed: 6buffer: 0 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0 0 0 0 producer:1 pointer_p:10 produced:18buffer: 0 0 0 0 0 0 0 0 0 8 18 0 0 0 0 0 0 0 0 0buffer: 0 0 0 0 0 0 0 0 0 0 18 0 0 0 0 0 0 0 0 0 producer:2 pointer_p:11 produced:10buffer: 0 0 0 0 0 0 0 0 0 0 18 10 0 0 0 0 0 0 0 0 producer:4 pointer_p:12 produced:10buffer: 0 0 0 0 0 0 0 0 0 0 18 10 10 0 0 0 0 0 0 0 consumer:4 pointer_c:10 consumed:18buffer: 0 0 0 0 0 0 0 0 0 0 0 10 10 0 0 0 0 0 0 0 producer:3 pointer_p:13 produced: 3buffer: 0 0 0 0 0 0 0 0 0 0 0 10 10 3 0 0 0 0 0 0 consumer:3 pointer_c:11 consumed:10buffer: 0 0 0 0 0 0 0 0 0 0 0 0 10 3 0 0 0 0 0 0 consumer:2 pointer_c:12 consumed:10buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 3 0 0 0 0 0 0 producer:1 pointer_p:14 produced: 6buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 3 6 0 0 0 0 0 consumer:1 pointer_c:13 consumed: 3buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 0 0 0 0 0 producer:2 pointer_p:15 produced:18buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 18 0 0 0 0 consumer:5 pointer_c:14 consumed: 6buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 18 0 0 0 0 producer:1 pointer_p:16 produced: 6buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 18 6 0 0 0 producer:3 pointer_p:17 produced:19buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 18 6 19 0 0 consumer:1 pointer_c:15 consumed:18buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 19 0 0 producer:5 pointer_p:18 produced: 7buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 19 7 0 consumer:3 pointer_c:16 consumed: 6buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 19 7 0 producer:4 pointer_p:19 produced:14buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 19 7 14 consumer:5 pointer_c:17 consumed:19buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 7 14 consumer:4 pointer_c:18 consumed: 7buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 producer:1 pointer_p: 0 produced: 4buffer: 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 consumer:2 pointer_c:19 consumed:14buffer: 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 consumer:1 pointer_c: 0 consumed: 4buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0buffer: 0 15 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0producer:3 pointer_p: 2 produced:13buffer: 0 15 13 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0producer:2 pointer_p: 3 produced: 3buffer: 0 15 13 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0说明：“producer:2”是指自定义标号为2的producer，“pointer_p:3”是指该producer的指针，“produced:3”是指该producer在buffer[3]里写入3，“buffer: 0 15 13 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ”是指该producer进行写操作后存储区的内容。