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

实验报告二实验名称:一、生产者-消费者问题的多线程解决方案二、设计一个执行矩阵乘法的多线程程序日期：2015-10-22 班级：13级计科学号:姓名：一、实验目的1.掌握线程的同步与互斥2.掌握生产者消费者的实现问题3.掌握多线程的编程方法4.掌握矩阵乘法的基本计算原理以及实现二、实验内容1.生产者-消费者问题的多线程解决方案2.设计一个执行矩阵乘法的多线程程序三、项目要求与分析1．请查阅资料，掌握线程创建的相关知识以及矩阵乘法的相关知识，了解java语言程序编写的相关知识2．理解线程的实验步骤在本次试验中，以“生产者-消费者”模型为依据，提供了一个多线程的“生产者-消费者”实例，编写java代码调试运行结果，得出相应的结论。

理解矩阵乘法的实验步骤四、具体实现1.生产者-消费者实例（1）创建一个缓冲信息发送接收通道接口，并创建邮箱盒子类实现，主要代码如下：//通道接口public interface Channelpublic abstract void send(Object item);public abstract Object receive();}//实现接口public class MessageQueue implements Channel{private Vector queue;public MessageQueue(){queue=new Vector();}public void send(Object item){queue.addElement(ite m);}public Object receive(){if(queue.size()==0)return null;elsereturn queue.remove(0);}}（2）创建一个工厂多线程类（启动生产者和消费者），并且添加main函数进行测试，主要代码如下：//工厂类与主方法public class Factory{public Factory(){Channel mailBox=new MessageQueue();Thread producerThread=new Thread(newProducer(mailBox));Thread consumerThread=new Thread(newConsumer(mailBox));producerThread.start();consumerThread.start();}public static void main(String[] args)Factory server=new Factory();}（3）创建一个线程睡眠类，用于测试，主要代码如下：public class SleepUtilities{public static void nap(){nap(NAP_TIME);}public static void nap(int duration){int sleeptime = (int)(NAP_TIME * Math.random());try{ Thread.sleep(sleeptime*1000); }catch (InterruptedException e) {}}private static final int NAP_TIME = 5;（4）创建生产者类实现Runnable，主要代码如下：public class Producer implements Runnable{private Channel mbox;public Producer(Channel mbox){this.mbox=mbox;}public void run(){Date message;while(true){SleepUtilities.nap();message=new Date();System.out.println("Producer produced "+message);mbox.send(message);}}}（5）创建消费者类实现Runnable，主要代码如下：public class Consumer implements Runnable{private Channel mbox;public Consumer(Channel mbox){this.mbox=mbox;}public void run(){Date message;while(true){SleepUtilities.nap();message=(Date)mbox.receive();if(message!=null)System.out.println("Consumer consumed "+message);}}}（6）调试程序，运行结果：2.矩阵乘法实例（1）初始化矩阵(便于观察，这里使用随机数生成矩阵)，主要初始化代码如下matrix1 = new int[m][k];matrix2 = new int[k][n];matrix3 = new int[m][n];//随机初始化矩阵a,bfillRandom(matrix1);fillRandom(matrix2);static void fillRandom(int[][] x){for (int i=0; i<x.length; i++){for(int j=0; j<x[i].length; j++){//每个元素设置为0到99的随机自然数x[i][j] = (int) (Math.random() * 100);}}}（2）打印输出矩阵函数，主要代码如下：static void printMatrix(int[][] x){for (int i=0; i<x.length; i++){for(int j=0; j<x[i].length; j++){System.out.print(x[i][j]+" ");}System.out.println("");}System.out.println("");}（3）创建多线程类，并实现Runnable接口同步对矩阵进行分行计算，主要代码如下：//创建线程,数量 <= 4for(int i=0; i<4; i++){if(index < m){Thread t = new Thread(new MyThread());t.start();}else{break;}synchronized static int getTask(){if(index < m){return index++;}return -1;}}class MyThread implements Runnable{int task;//@Overridepublic void run(){MultiThreadMatrix.threadCount++;while( (task = MultiThreadMatrix.getTask()) != -1 ) {System.out.println("进程:"+Thread.currentThread().getName()+"\t开始计算第"+(task+1)+"行");for(int i=0; i<MultiThreadMatrix.n; i++) {for(int j=0; j<MultiThreadMatrix.k; j++) {MultiThreadMatrix.matrix3[task][i] +=MultiThreadMatrix.matrix1[task][j] *MultiThreadMatrix.matrix2[j][i];}}}MultiThreadMatrix.threadCount--;}（4）通过不断改变矩阵大小，线程数目，，调试程序，运行结果：五、所遇问题与解决方法1.在生产者-消费者多线程试验中，刚开始没有考虑到使用线程睡眠，运行结果速度之快，没法观看数据变化，后面定义了睡眠控制，使得问题得以解决2.在多线程矩阵开发实验中，刚开始定义矩阵太小，测试结果不太明显，后面通过把矩阵改大，并且线程数目不断变化使得结果明显。

目录1.需求分析 (2)1.1 课程设计题目 (2)1.2 课程设计任务 (2)1.3 课程设计原理 (2)1.4 课程设计要求 (2)1.5 实验环境 (2)2. 概要设计 (3)2.1 课程设计方案概述 (3)2.2 课程设计流程图 (3)3.详细设计 (4)3.1 主程序模块 (4)3.2 生产者程序模块 (5)3.3 消费者程序模块 (6)4.调试中遇到的问题及解决方案 (6)5.运行结果 (7)6.实验小结 (7)参考文献 (8)附录：源程序清单 (8)1.需求分析1.1 课程设计题目用多线程同步方法解决生产者－消费者问题1.2 课程设计任务（1）每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的全部内容、当前指针位置和生产者／消费者线程的标识符。

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

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

1.3 课程设计原理生产者和消费者问题是从操作系统中的许多实际同步问题中抽象出来的具有代表性的问题，它反映了操作系统中典型的同步例子，生产者进程(进程由多个线程组成)生产信息，消费者进程使用信息，由于生产者和消费者彼此独立，且运行速度不确定，所以很可能出现生产者已产生了信息而消费者却没有来得及接受信息这种情况。

为此，需要引入由一个或者若干个存储单元组成的临时存储区（即缓冲区），以便存放生产者所产生的信息，解决平滑进程间由于速度不确定所带来的问题。

1.4 课程设计要求(1)有界缓冲区内设有20个存储单元，放入／取出的数据项设定为1~20这20个整型数。

(2)每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的全部内容、当前指针位置和生产者／消费者线程的标识符。

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

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

1.5 实验环境系统平台：LINUX开发语言：C开发工具：PC机一台2. 概要设计2.1 课程设计方案概述本设计中设置一个长度为20的一维数组buff[20]作为有界缓冲区，缓冲区为0时，代表该缓冲区内没有产品，buff[i]=i+1表示有产品，产品为i+1。

《操作系统》课程设计题目：“生产者-消费者”问题学院：信息工程学院专业：计算机科学与技术班级：计科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、设计目的：通过研究Linux的进程同步机制和信号量，实现生产者消费者问题的并发控制。

2、说明：有界缓冲区内设有20个存储单元，放入取出的产品设定为20个100以内的随机整数。

3、设计要求：1)生产者与消费者均有二个以上2)生产者和消费者进程的数目在程序界面上可调，在运行时可随时单个增加与减少生产者与消费者3)生产者的生产速度与消费者的消费速度均可在程序界面调节，在运行中，该值调整后立即生效4)生产者生产的产品由随机函数决定5)多个生产者或多个消费者之间必须有共享对缓冲区进行操作的函数代码6)每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的全部内容、当前生产者与消费者的指针位置，以及生产者和消费者线程标识符7)采用可视化界面，可在运行过程中随时暂停，查看当前生产者、消费者以及有界缓冲区的状态三、系统分析与设计1、系统分析系统分析1.此次课程设计的任务是生产者消费者问题的模拟演示，需要处理的数据有：生产者进程数目，消费者进程数目，生产者生产速度，消费者消费速度，缓冲区中产品的个数，以及生产、消费产品的指针。

2.程序中需要缓冲区中的信息可以动态演示，生产者、消费者的个数以及生产、消费时的速度可以随时调节，同时为了使程序更加友好，应该具有开始、暂停、停止等相关可操作按钮。

学号：课程设计题目用多线程同步方法解决生产者－消费者问题(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）有界缓冲区可用数组实现。

未定义书签。
未定义书签。
未定义书签。
未定义书签。
未定义书签。
.错.误！未定义书签。
.错.误！未定义书签。
.3...
.5...
.2..0.
、题目：
用多进程同步方法ห้องสมุดไป่ตู้决生产者-消费者问题。
掌握信号量机制的过程。
掌握c语言编程。
通过研究Linux的进程机制和信号量实现生产者消费者问题的并发控制。
资源时，可以看作是消耗，且该进程称为消费者。
操作系统课程设计
用多进程同步方法解决生产者-消费者问题
别:
计算机科学与技术
级:
04级4班
口
号:
名:
间:
2006-7-7—2006-7-14
一、题目：
二、设计目的：
三、总体设计思想概述：
四、说明：
五、设计要求：
六、设计方案：
七、流程图：
八、运行结果
九、源程序
十、总结
一、参考文献
.错.误！
.错.误！
.错.误！

生产者消费者问题操作系统课程设计生产者消费者问题是操作系统中常见的一个并发问题，本课程设计旨在帮助学生深入理解该问题及其解决方案。

课程设计内容包括：
1. 生产者消费者问题的定义、特点和解决方案
2. 生产者消费者问题的算法设计与实现
3. 多线程并发编程实践
4. 操作系统调度与同步机制实践
5. 生产者消费者问题的应用场景与案例分析
通过本课程设计，学生将能够掌握操作系统中的重要问题与解决方案，并具备多线程并发编程的实践技能，为以后的操作系统开发与应用打下坚实的基础。

- 1 -。

实验报告（学生打印后提交）实验名称: 生产者和消费者问题实验时间: 2023年 5 月 5日●实验人员:●实验目的：掌握基本的同步互斥算法, 理解生产者和消费者模型。

●了解Windows 2023/XP中多线程的并发执行机制, 线程间的同步和互斥。

●学习使用Windows 2023/XP中基本的同步对象, 掌握相应的API●实验环境: WindowsXP ＋ VC++6.0●运用Windows SDK提供的系统接口（API, 应用程序接口）完毕程序的功能。

API是操作系统提供的用来进行应用程序设计的系统功能接口。

使用API, 需要包含对API函数进行说明的SDK头文献, 最常见的就是windows.h实验环节:1.读懂源程序.2.编辑修改源程.......................................实验陈述:1.基础知识:本实验用到几个API函数：CreateThread CreateMutex, WaitForSingleObject, ReleaseMutexCreateSemaphore, WaitForSingleObject, ReleaseSemaphore, ReleaseMutex, nitializeCriticalSection, EnterCriticalSection, LeaveCriticalSection。

这些函数的作用：CreateThread, 功能：创建一个线程, 该线程在调用进程的地址空间中执行。

CreateMutex,功能：产生一个命名的或者匿名的互斥量对象。

WaitForSingleObject（相应p操作）锁上互斥锁, ReleaseMutex（相应v操作）打开互斥锁.。

CreateSemaphore, 创建一个命名的或者匿名的信号量对象。

信号量可以看作是在互斥量上的一个扩展。

WaitForSingleObject, 功能：使程序处在等待状态, 直到信号量（或互斥量）hHandle出现或者超过规定的等待最长时间, 信号量出现指信号量大于或等于1, 互斥量出现指打开互斥锁。

多线程⽣产者消费者问题处理⼀、⽐较低级的办法是⽤wait和notify来解决这个问题。

消费者⽣产者问题：这个问题是⼀个多线程同步问题的经典案例，⽣产者负责⽣产对象，消费者负责将⽣成者产⽣的对象取出，两者不断重复此过程。

这过程需要注意⼏个问题：不论⽣产者和消费者有⼏个，必须保证：1.⽣产者每次产出的对象必须不⼀样，产⽣的对象有且仅有出现⼀次；2.消费者每次取出的对象必须不⼀样，取出的对象有且仅有出现⼀次；3.⼀定是先产⽣该对象，然后对象才能被取出，顺序不能乱；第⼀种情况：多个⽣产者轮流负责⽣产，多个消费者负责取出。

⼀旦⽣产者产⽣⼀个对象，其他⽣产者不能⽣产，只能由消费者执⾏取出操作；需要的对象有商品类、消费者、⽣产者；//测试类public class ProducerConsumer {public static void main(String[] args) {// 定义资源对象Resource r = new Resource();//定义⼀个⽣产者和⼀个消费者Producer p = new Producer(r);Consumer c = new Consumer(r);//启动四个线程，2个负责⽣产者，两个消费者Thread t1 = new Thread(p);Thread t2 = new Thread(p);Thread t3 = new Thread(c);Thread t4 = new Thread(c);t1.start();t2.start();t3.start();t4.start();}}//商品类class Resource{private String name;private int count = 1;private boolean flag = false;//产⽣商品public synchronized void set(String name) {while (flag) {try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}} = name + "---" + count++;System.out.println(Thread.currentThread().getName() + " ⽣产者" + );flag = true;//唤醒所有线程this.notifyAll();}//取出商品public synchronized void out() {while (!flag) {try {wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(Thread.currentThread().getName() + " 消费者________" + );flag = false;this.notifyAll();}}//定义⽣产者class Producer implements Runnable{private Resource res;public Producer(Resource res) {this.res = res;}@Overridepublic void run() {while (true) {res.set("+商品+");}}}//定义消费者class Consumer implements Runnable{private Resource res;Consumer(Resource res) {this.res = res;}@Overridepublic void run() {while (true) {res.out();}}}运⾏结果是产⽣⼀个，随即取出⼀个，循环往复，其运⾏结果的部分如下：Thread-2 消费者________+商品+---67821Thread-1 ⽣产者+商品+---67822Thread-3 消费者________+商品+---67822Thread-0 ⽣产者+商品+---67823Thread-2 消费者________+商品+---67823Thread-1 ⽣产者+商品+---67824Thread-3 消费者________+商品+---67824Thread-0 ⽣产者+商品+---67825Thread-2 消费者________+商品+---67825Thread-1 ⽣产者+商品+---67826Thread-3 消费者________+商品+---67826Thread-0 ⽣产者+商品+---67827Thread-2 消费者________+商品+---67827Thread-1 ⽣产者+商品+---67828Thread-3 消费者________+商品+---67828Thread-0 ⽣产者+商品+---67829Thread-2 消费者________+商品+---67829Thread-1 ⽣产者+商品+---67830Thread-3 消费者________+商品+---67830Thread-0 ⽣产者+商品+---67831Thread-2 消费者________+商品+---67831Thread-1 ⽣产者+商品+---67832第⼆种情况：⽬标：⽣产者与消费者轮换着抢夺执⾏权，但是⽣产者最多可以库存5个，消费者最多可以连续取出5个此时需要定义⼀种中间对象：仓库类。

课程设计报告课程名称：操作系统实验题目：用多进程同步方法解决生产者-消费者问题院系：计算机科学与工程学院班级：姓名：学号：指导老师：一、概述：1、问题描述：用多进程同步方法解决生产者-消费者问题设计目的:通过研究Linux 的进程机制和信号量实现生产者消费者问题的并发控制.说明:有界缓冲区内设有20个存储单元,放入/取出的数据项设定为1-20这20个整型数.设计要求:1) 每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的全部内容,当前指针位置和生产者/消费者线程的标识符.2) 生产者和消费者各有两个以上.3) 多个生产者或多个消费者之间须有共享对缓冲区进行操作的函数代码.2、程序设计基本思想:生产者—消费者问题是一种同步问题的抽象描述。

计算机系统中的每个进程都可以消费或生产某类资源。

当系统中某一进程使用某一资源时，可以看作是消耗，且该进程称为消费者。

而当某个进程释放资源时，则它就相当一个生产者。

一个有限空间的共享缓冲区，负责存放货物。

生产者向缓冲区中放物品，缓冲区满则不能放。

消费者从缓冲区中拿物品，缓冲区空则不能拿。

因为有多个缓冲区，所以生产者线程没有必要在生成新的数据之前等待最后一个数据被消费者线程处理完毕。

同样，消费者线程并不一定每次只能处理一个数据。

在多缓冲区机制下，线程之间不必互相等待形成死锁，因而提高了效率。

多个缓冲区就好像使用一条传送带替代托架，传送带上一次可以放多个产品。

生产者在缓冲区尾加入数据，而消费者则在缓冲区头读取数据。

当缓冲区满的时候，缓冲区就上锁并等待消费者线程读取数据；每一个生产或消费动作使得传送带向前移动一个单位，因而，消费者线程读取数据的顺序和数据产生顺序是相同的。

可以引入一个count计数器来表示已经被使用的缓冲区数量。

用Producer和Consumer 来同步生产者和消费者线程。

每当生产者线程发现缓冲区满（ count=BufferSize ），它就等待Consumer事件。

北方民族大学课程设计报告系（部、中心）计算机科学与工程学院姓名杨和平学号 20060309 专业计算机科学与工程学院班级 1 同组人员课程名称计算机操作系统课程设计设计题目多进程同步方法解决生产者－消费者问题起止时间 2008年12月15日—2008年12月26日成绩指导教师签名韩强北方民族大学教务处制多进程同步方法解决生产者－消费者问题摘要本文论述了多进程同步方法解决生产者－消费者问题的过程。

该程序使学生对操作系统的工作机制有了初步的了解，其主要目的是使学生了解和撑握在Linux系统平台下的C语言编程，用来解决实现生活中遇到的问题。

并以Linux 系统开发平台，以及虚拟机来实现。

关键字：生产者－消费者问题，Linux系统平台，虚拟机，信号量，线程(thread)目录一、课程设计所需设备 (4)二、课程设计预期目的 (4)三、课程设计任务 (4)四、课程设计基本思想 (4)五．详细设计 (5)5.1．调试工具简介VI(VISUAL EDITOR) (5)5.2、调试问题分析 (5)5.3、程序流程图 (7)5.4、程序自定义函数 (8)5.5、系统函数调用 (8)六．源程序清单 (10)6.1、/*源程序PV.C*/ (10)6.2、编译及运行结果 (15)七．课程设计总结 (19)符录:参考文献 (19)多进程同步方法解决生产者－消费者问题一、课程设计所需设备计算机一台，Red Hat linux9.03系统一套。

二、课程设计预期目的通过研究Linux 的进程机制和信号量实现生产者消费者问题的并发控制。

三、课程设计任务1、每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的全部内容,当前指针位置和生产者/消费者县城的标识符；2、生产者和消费者各有两个以上；3、多个生产者或多个消费者之间须有共享对缓冲区进行操作的函数码。

4、有界缓冲区内设有20个存储单元,放入/取出的数据项设定为1-20这20个整型数。

实验报告专业网络工程班级08102班学号01号姓名胡双双课程名称操作系统学年2010－2011 学期下课程类别专业必修■限选□任选□实践□实验时间2010年11月3日实验名称实验一：生产者与消费者问题实验目的和要求全面理解生产者与消费者问题模型，掌握解决该问题的算法思想，正确使用同步机制。

实验软硬件要求Pentium(R) Dual-Core CPU 1.96G内存WINDOWS XP ProfessionalVisual C++6.0实验内容、方法和步骤（可附页）问题描述：一组生产者向一组消费者提供商品，共享一个有界缓冲池，生产者向其中放入商品，消费者从中取得商品。

假定这些生产者和消费者互相等效，只要缓冲池未满，生产者可将商品送入缓冲池；只要缓冲池未空，消费者可从缓冲池取走一商品。

功能要求：根据进程同步机制，编写一个解决上述问题的程序，可显示缓冲池状态、放商品、取商品等过程。

具体参数：有1个生产者进程；有1个消费者进程；缓冲区单元个数BUFFER_NUM =5；不同的生产进程可生产不同的产品，自己可任意定义，在本程序中是直接将相应生产者代号放入缓冲区，消费时将某消费者消费某生产者的信息显示出来实验结果：见截图小结从此次试验中，学到了很多关于编程的知识，以前对于编程的认识只停留在一些简单的算法上，并没有系统的进行编程训练。

此次的试验是以前从没接触过的多线程，中间涉及的同步及互斥问题，在设计软件及系统时，都是极其重要的。

多线程实验对于我们现阶段确实有点偏难，不过，在经过请教同学及看参考书，终于自己写出了一个相对于简单一点的生产者消费者的多线程程序。

评定成绩：批阅教师：年月日一、问题概述一组生产者向一组消费者提供消息，它们共享一个有界缓冲池，生产者向其中投放消息，消费者从中取得消息。

假定这些生产者和消费者互相等效，只要缓冲池未满，生产者可将消息送入缓冲池；只要缓冲池未空，消费者可从缓冲池取走一个消息。

用多线程实现生产者消费者同步问题1、设计思路生产者线程和消费者线程。

生产者线程生产产品，然后将物品放置在一个空缓冲区中供消费者线程消费。

消费者线程从缓冲区中获得产品，然后释放缓冲区。

生产者线程生产产品时，若无空缓冲区可用，生产者线程必须等待消费者线程释放出一个空缓冲区；消费者线程消费产品时，若缓冲区为空，消费者线程将被阻塞，直到新的产品被生产出来。

2、流程图生产者线程的流程图：消费者线程的流程图：3、实验结果（截图）生产者连续生产三个产品，消费者消费一个产品：当缓冲区已满时，生产者将无法在缓冲区内放入产品：当缓冲区为空时，消费者将无法在缓冲区内取到产品：4、源代码#include<stdio.h>#include<windows.h># define buf_size 4 // 缓冲区个数int mutex[buf_size]={0,0,0,0};int buffer[buf_size]={0,0,0,0};//初始化缓冲区为空HANDLE p_cMutex; //用于线程间的互斥void show(){for(int i=0;i<buf_size;i++){printf("第%d个缓冲区为：%d\n",i,buffer[i]);}printf("\n--------------------------------\n");}DWORD WINAPI Producer(LPVOID lpPara){while(1){for(int i=0;i<buf_size;i++){if(buffer[i]==0){if(mutex[i]==0){mutex[i]=1;//加锁WaitForSingleObject(p_cMutex,INFINITE);buffer[i]=1;printf("生产出一个产品，已放入第%d个缓冲区\n",i);show();Sleep(1000);ReleaseMutex(p_cMutex);mutex[i]=0;//解锁}break;}}if(i==buf_size)printf("缓冲区已满，请等待\n"); //缓冲区已满，请等待Sleep(1000);}}DWORD WINAPI Customer(LPVOID lpPara){while(true){for(int j=0;j<buf_size;j++){if(buffer[j]==1){if(mutex[j]==0){mutex[j]=1;//加锁WaitForSingleObject(p_cMutex,INFINITE);buffer[j]=0;printf("消费者已消费第%d个缓冲区的产品\n",j);show();Sleep(1000);ReleaseMutex(p_cMutex);mutex[j]=0;//解锁}break;}}if(j==buf_size)printf("没有产品可消费，请等待\n"); //没有产品可消费，请等待Sleep(1000);}}int main(int argc,char* argv[]){HANDLE handle[4];p_cMutex = CreateMutex(NULL,FALSE,NULL);for(int i=0;i<3;i++){handle[i]=CreateThread(NULL,0,Producer,NULL,0,NULL);}for(i=3;i<4;i++){handle[i]=CreateThread(NULL,0,Customer,NULL,0,NULL);}while(getchar()=='\n') break;return 0;}。

架，传送带上一次可以放多个产品。生产者在缓冲区尾加入数据，而消费者则在缓冲区头读取数据。当缓冲区满的时候，缓冲区就上锁并等待消费者线程读取数据；每一个生产或消费动作使得传送带向前移动一个单位，因而，消费者线程读取数据的顺序和数据产生顺序是相同的。
可以引入一个count计数器来表示已经被使用的缓冲区数量。用Producer和Consumer来同步生产者和消费者线程。每当生产者线程发现缓冲区满（count=BufferSize），它就等待Consumer事件。同样，当消费者线程发现缓冲区空，它就开始等待Producer。生产者线程写入一个新的数据之后，就立刻发出Consumer来唤醒正在等待的消费者线程；消费者线程在读取一个数据之后，就发出Producer来唤醒正在等待的生产者线程。
通过一个有界缓冲区(用数组来实现，类似循环队列)把生产者和消费者联系起来。假定生产者和消费者的优先级是相同的，只要缓冲区未满，生产者就可以生产产品并将产品送入缓冲区。类似地，只要缓冲区未空，消费者就可以从缓冲区中去走产品并消费它。应该禁止生产者向满的缓冲区送入产品，同时也应该禁止消费者从空的缓冲区中取出产品，这一机制有生产者线程和消费者线程之间的互斥关系来实现。
二
m个生产者、k个消费者、共享n个单元缓冲区
基本算法如下：
三
4.1、生产者流程结构：
4.2消费者流程结构：
四
a)用一个整型数组Buffer_NUM来代表缓冲区。生产产品及对已有产品消费都需要访问该组缓冲区。
缓冲区的大小和结构体：
struct Buffer
{
int product[BUFFER_NUM]; //缓冲区
int start, end; //两个指针相当于教材中的in out指针

格式： V。IDEnterCriticalSection( LPCRITICAL_SECTI。NIpCnticalSection )； LeaveCriticalSection的用法 功能：释放指定临界区对象的所有权。 格式： V。IDLeaveCriticalSection( LPCRITICAL.SECTI。NIpCriticalSection )； 2)程序结构 MI-I和序结构图 3)数据结构 (1)用一个整型数组Buffer-Critical来代表缓冲区。不管是生产产品还是对已有产品的消费都
Fer(inti-∙zi<R.reqvestHunU∙∙)
n_tħrei。.re<∣ι>tst[1]-((Thread!i⅞Fφ∙)(p))->thre⅛d.reqvest(1];
$10，P(LSl刊)；
F∙r(l-∙U<R..req<∣p⅝tHuAU*∙)<
printfCXoo⅞uι⅞erVdrequesttoconς∣>aeVdpro^uct∖n-t∙-serlil.n_thr^a<l_requ«Mlt_for_sefuiphorPVanFarSinglp。bject(b_S^Mphor»(ii_thrp^d_reqiiest[i])v*-1);
文件G)⅛M∙Z)2«(X)收就")工具(D隅船。i) r^i∙-。CAftφct∙taisg4S∙S∖n<s∖Mmm6lr∙t0tA4面3f⅞文件夹∖*JfFl 文件和文件关任务 J创建一个新文件夹 θ将这个文件英宣布到 WHtb H共享，及伴英 IT*+6Y。rkSP∙c∙ Urn C*÷Ssιrc∙6KB Un VV忖Inttllistns 25KB 10簪巷

操作系统课程设计用多进程同步方法解决生产者-消费者问题系别：计科系专业: 计算机科学与技术班级：.04级4班姓名：. 苏德洪目录一、题目：.................................................... 3.. .二、设计目的：.................................................... 3.. .三、总体设计思想概述：............................. 3..四、说明：.................................................... 3.. .五、设计要求：.................................................... 3.. .六、设计方案：.................................................... 3.. .七、流程图：.................................................... 5...八、运行结果.................................................... 7.. .九、源程序 (11)十、总结................................................... 1..9 ..十一、参考文献................................................... 2..0 .一、题目：用多进程同步方法解决生产者- 消费者问题。

二、设计目的：掌握信号量机制的过程。

掌握 c 语言编程。

通过研究Linux 的进程机制和信号量实现生产者消费者问题的并发控制。

三、总体设计思想概述：1、生产者—消费者问题是一种同步问题的抽象描述。

java多线程解决⽣产者消费者问题/** ⽣产者和消费者案例*/public class TestProductorAndConsumer {public static void main(String[] args) {Clerk clerk = new Clerk();Productor pro = new Productor(clerk);Consumer cus = new Consumer(clerk);new Thread(pro, "⽣产者 A").start();new Thread(cus, "消费者 B").start();}}//店员class Clerk{private int product = 0;//进货public synchronized void get(){//循环次数：0while(product >= 1){//为了避免虚假唤醒问题，应该总是使⽤在循环中System.out.println("产品已满！");try {this.wait();} catch (InterruptedException e) {}}System.out.println(Thread.currentThread().getName() + " : " + ++product);this.notifyAll();}//卖货public synchronized void sale(){//product = 0; 循环次数：0while(product <= 0){System.out.println("缺货！");try {this.wait();} catch (InterruptedException e) {}}System.out.println(Thread.currentThread().getName() + " : " + --product);this.notifyAll();}}//⽣产者class Productor implements Runnable{private Clerk clerk;public Productor(Clerk clerk) {this.clerk = clerk;}@Overridepublic void run() {for (int i = 0; i < 20; i++) {try {Thread.sleep(200);} catch (InterruptedException e) {}clerk.get();}}}//消费者class Consumer implements Runnable{private Clerk clerk;public Consumer(Clerk clerk) {this.clerk = clerk;@Overridepublic void run() {for (int i = 0; i < 20; i++) {clerk.sale();}}}上边代码主要介绍了java多线程解决⽣产者消费者问题的⽅法,实例分析了java采⽤多线程的⽅法解决⽣产者消费者问题的相关技巧,需要的朋友可以参考下另外concurrent 包下⾯在执⾏多线程的时候也给出了特性阻塞队列 BlockingQueue ⽤法如下：也可以实现⽣产者和消费者模式import java.util.concurrent.BlockingQueue;import java.util.concurrent.LinkedBlockingQueue;public class Test {public static void main(String[] args) {//固定容器⼤⼩为10BlockingQueue<Food> foods = new LinkedBlockingQueue<Food>(10);Thread produce = new Thread(new Produce(foods));Thread consume = new Thread(new Consume(foods));produce.start();consume.start();}}/*** ⽣产者*/class Produce implements Runnable {private BlockingQueue<Food> foods;Produce(BlockingQueue<Food> foods) {this.foods = foods;}@Overridepublic void run() {int i = 0;while (i <= 10) {try {//当⽣产的⾷品数量装满了容器，那么在while⾥⾯该⾷品容器(阻塞队列)会⾃动阻塞 wait状态等待消费foods.put(new Food("⾷品" + i));i++;} catch (InterruptedException e) {e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.}}}}/*** 消费者*/class Consume implements Runnable {private BlockingQueue<Food> foods;Consume(BlockingQueue<Food> foods) {this.foods = foods;}@Overridepublic void run() {try {Thread.sleep(1000); //⽤于测试当⽣产者⽣产满10个⾷品后是否进⼊等待状态while (true) {//当容器⾥⾯的⾷品数量为空时，那么在while⾥⾯该⾷品容器(阻塞队列)会⾃动阻塞 wait状态等待⽣产Food food = foods.take();System.out.println("消费" + food.getName());}} catch (InterruptedException e) {e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.}}}* ⾷品*/class Food {private String name;String getName() {return name;}Food(String name) { = name;System.out.println("⽣产" + name); }}。