生产者与消费者实验报告

合集下载

生产者消费者实验报告

生产者消费者实验报告

生产者消费者实验报告生产者消费者实验报告引言:生产者消费者模型是计算机科学中的一个经典问题,用于解决多线程并发访问共享资源的同步问题。

在本实验中,我们通过编写一个简单的Java程序来模拟生产者消费者模型,并观察其运行结果和效果。

一、实验背景生产者消费者模型是一种常见的并发模型,用于解决多线程访问共享资源时可能出现的数据竞争和同步问题。

在该模型中,生产者负责生产数据并将其放入共享缓冲区,而消费者则负责从缓冲区中取出数据进行消费。

为了确保生产者和消费者之间的同步与互斥,需要使用合适的同步机制,如信号量、互斥锁等。

二、实验目的本实验的主要目的是通过编写一个简单的生产者消费者程序,验证该模型在多线程环境下的正确性和效果。

我们将通过观察程序的输出结果和运行时间来评估其性能,并分析其中可能存在的问题和改进空间。

三、实验设计1. 编写生产者类和消费者类:我们首先定义了一个共享缓冲区,用于存储生产者生产的数据。

然后,我们编写了一个生产者类和一个消费者类,分别实现了生产者和消费者的逻辑。

在生产者类中,我们使用了一个循环来模拟生产者不断地生产数据,并将其放入缓冲区。

而在消费者类中,我们同样使用了一个循环来模拟消费者不断地从缓冲区中取出数据进行消费。

2. 同步机制的选择:为了保证生产者和消费者之间的同步与互斥,我们选择了信号量作为同步机制。

在生产者类中,我们使用一个信号量来控制缓冲区的可用空间,当缓冲区已满时,生产者将等待,直到有可用空间。

而在消费者类中,我们同样使用一个信号量来控制缓冲区的可用数据,当缓冲区为空时,消费者将等待,直到有可用数据。

3. 实验参数的设置:为了模拟真实的生产者消费者场景,我们设置了以下参数:- 缓冲区大小:10- 生产者数量:3- 每个生产者生产的数据量:1000- 消费者数量:2四、实验结果与分析在运行实验程序后,我们观察到以下结果:1. 生产者和消费者之间的同步与互斥得到了有效保证,生产者在缓冲区已满时会等待,直到有可用空间;消费者在缓冲区为空时会等待,直到有可用数据。

操作系统生产者与消费者问题实验报告

操作系统生产者与消费者问题实验报告

《操作系统》实验报告生产者和消费者的问题一、实验目的1.掌握基本的同步与互斥的算法,理解基本的生产者与消费者的模型。

2.学习使用Windows 2000/XP中基本的同步对象,掌握相关的API的使用方法。

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

二、实验的内容及其要求1.实验内容以生产者/消费者模型为根据,在Windows 2000环境下创建一个控制台进程,在改进程中创建n个线程模拟生产者和消费者,实现进程(线程)的同步与互斥。

2.实验要求①学习并理解生产者/消费者模型及其同步/互斥规则②学习了解Windows同步对象及其特性③熟悉实验环境,掌握相关API的使用方法④设计程序,实现生产者/消费者进程(线程)的同步与互斥⑤提交实验报告三、实验的时间安排1.实验前,先到图书馆或上网百度了解有关生产者/消费者模型的相关知识,建立生产者/消费者模型的基本概念。

2.利用13周、15周、17周的上机时间编写和调试程序代码。

3.利用其他课余时间来分析实验的最终结果并完成相关的实验报告。

四、实验的环境1.硬件条件:普通计算机一台2.软件条件:①操作系统:Windows 2000/XP②开发语言:VC++本实验是在Windows 2000+VC6.0环境下实现的,利用Windows SDK提供的系统接口(API)完成程序的功能。

实验在Windows 下安装VC后进行,因为VC是一个集成开发环境,其中包含了Windows SDK所有工具和定义,所以安装了VC后就不用特意安装SDK了。

实验中所用的API(应用程序接口),是操作系统提供的用来进行应用程序设计的系统功能接口。

要使用这些API,需要包含对这些函数进行说明的SDK头文件,最常见的就是windows.h。

一些特殊的API调用还需要包含其他的头文件。

五、正文1.程序结构图:2.数据结构:(1)用一个整型数组Buffer_Critical来代表缓冲区。

生产者消费者问题实验报告

生产者消费者问题实验报告

河北建筑工程学院实验报告年月日班级物联121姓名连龙学号2012326134评分实验台号同组人员实验名称生产者消费者问题实验课程名称操作系统仪器名称型号规格仪器编号PC机Window XP或Windows 7一、实验目的理解生产者消费者问题,理解生产者产生任务进入缓存或队列排队等待处理,消费者在队列等待或进行任务处理的过程二、实验设备PC 机三、实验内容在java开发环境下模拟经典进程同步问题,生产者——消费者问题。

四、程序主要代码import java.awt.*;import javax.swing.*;import javax.swing.border.TitledBorder;import java.awt.event.*;public class abc extends JFrame implements ActionListener{static abc frm=new abc();static JButton bun1=new JButton("生产者1");static JButton bun2=new JButton("生产者2");static JButton bun3=new JButton("生产者3");static JButton bun4=new JButton("消费者1");static JButton bun5=new JButton("消费者2");static JButton bun6=new JButton("消费者3");static JTextField jt1 = new JTextField(" ");static JTextField jt2 = new JTextField(" ");static JTextField jt3 = new JTextField(" ");static JTextField jt4 = new JTextField(" ");static JTextField jt5 = new JTextField(" ");static JTextField jt6 = new JTextField(" ");static JTextField jt7 = new JTextField(" "); static JTextField jt8 = new JTextField(" ");public static void main(String[] args) {frm.setLayout(null);frm.setSize(800,450);frm.setLocation(500,300);bun1.addActionListener(frm);bun2.addActionListener(frm);bun3.addActionListener(frm);bun4.addActionListener(frm);bun5.addActionListener(frm);bun6.addActionListener(frm);bun1.setSize(80,40);bun1.setLocation(60,325);frm.add(bun1);bun2.setSize(80,40);bun2.setLocation(170,325);frm.add(bun2);bun3.setSize(80,40);bun3.setLocation(280,325);frm.add(bun3);bun4.setSize(80,40);bun4.setLocation(400,325);frm.add(bun4);bun5.setSize(80,40);bun5.setLocation(510,325);frm.add(bun5);bun6.setSize(80,40);bun6.setLocation(620,325);frm.add(bun6);jt1.setSize(80,40);jt1.setLocation(400,200);frm.add(jt1);jt2.setSize(80,40);jt2.setLocation(280,200);frm.add(jt2);jt3.setSize(80,40);jt3.setLocation(60,95);frm.add(jt3);jt4.setSize(80,40);jt4.setLocation(170,95);frm.add(jt4);jt5.setSize(80,40);jt5.setLocation(280,95);frm.add(jt5);jt6.setSize(80,40);jt6.setLocation(400,95);frm.add(jt6);jt7.setSize(80,40);jt7.setLocation(510,95);frm.add(jt7);jt8.setSize(80,40);jt8.setLocation(620,95);frm.add(jt8);frm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);frm.setVisible(true);}public void actionPerformed(ActionEvent e){JButton bun=(JButton)e.getSource();if(bun==bun1){if(jt6.getText().equals(" ")){if(jt1.getText().equals(" ")){jt1.setText(bun1.getText());}else if(jt2.getText().equals(" ")){jt2.setText(bun1.getText());}else if(jt3.getText().equals(" ")){jt3.setText(bun1.getText());bun1.setEnabled(false);}else if(jt4.getText().equals(" ")){jt4.setText(bun1.getText());bun1.setEnabled(false);}else if(jt5.getText().equals(" ")){jt5.setText(bun1.getText());bun1.setEnabled(false);}}else{if(jt7.getText().equals(" ")){jt6.setText(" ");bun4.setEnabled(true);bun5.setEnabled(true);bun6.setEnabled(true);}else if(jt8.getText().equals(" ")){jt6.setText(jt7.getText());jt7.setText(" ");if(jt6.getText().equals("消费者1")) {bun4.setEnabled(false);bun5.setEnabled(true);bun6.setEnabled(true);}else if(jt6.getText().equals("消费者2")) {bun4.setEnabled(true);bun5.setEnabled(false);bun6.setEnabled(true);}else{bun4.setEnabled(true);bun5.setEnabled(true);bun6.setEnabled(false);}}else{if(jt6.getText().equals("消费者1")) {bun4.setEnabled(true);bun5.setEnabled(false);bun6.setEnabled(false);}else if(jt6.getText().equals("消费者2")) {bun4.setEnabled(false);bun5.setEnabled(true);bun6.setEnabled(false);}else{bun4.setEnabled(false);bun5.setEnabled(false);bun6.setEnabled(true);}jt6.setText(jt7.getText());jt7.setText(jt8.getText());jt8.setText(" ");}}}else if(bun==bun2){if(jt6.getText().equals(" ")){if(jt1.getText().equals(" ")){jt1.setText(bun2.getText());}else if(jt2.getText().equals(" ")){jt2.setText(bun2.getText());}else if(jt3.getText().equals(" ")){jt3.setText(bun2.getText());bun2.setEnabled(false);}else if(jt4.getText().equals(" ")){jt4.setText(bun2.getText());bun2.setEnabled(false);}else if(jt5.getText().equals(" ")){jt5.setText(bun2.getText());bun2.setEnabled(false);}}else{if(jt7.getText().equals(" ")){jt6.setText(" ");bun4.setEnabled(true);bun5.setEnabled(true);bun6.setEnabled(true);}else if(jt8.getText().equals(" ")){jt6.setText(jt7.getText());jt7.setText(" ");if(jt6.getText().equals("消费者1")) {bun4.setEnabled(false);bun5.setEnabled(true);bun6.setEnabled(true);}else if(jt6.getText().equals("消费者2")) {bun4.setEnabled(true);bun5.setEnabled(false);bun6.setEnabled(true);}else{bun4.setEnabled(true);bun5.setEnabled(true);bun6.setEnabled(false);}}else{if(jt6.getText().equals("消费者1")) {bun4.setEnabled(true);bun5.setEnabled(false);bun6.setEnabled(false);}else if(jt6.getText().equals("消费者2")) {bun4.setEnabled(false);bun5.setEnabled(true);bun6.setEnabled(false);}else{bun4.setEnabled(false);bun5.setEnabled(false);bun6.setEnabled(true);}jt6.setText(jt7.getText());jt7.setText(jt8.getText());jt8.setText(" ");}}}else if(bun==bun3){ if(jt6.getText().equals(" ")){if(jt1.getText().equals(" ")){jt1.setText(bun3.getText());}else if(jt2.getText().equals(" ")){jt2.setText(bun3.getText());}else if(jt3.getText().equals(" ")){jt3.setText(bun3.getText());bun3.setEnabled(false);}else if(jt4.getText().equals(" ")){jt4.setText(bun3.getText());bun3.setEnabled(false);}else if(jt5.getText().equals(" ")){jt5.setText(bun3.getText());bun3.setEnabled(false);}}else{if(jt7.getText().equals(" ")){jt6.setText(" ");bun4.setEnabled(true);bun5.setEnabled(true);bun6.setEnabled(true);}else if(jt8.getText().equals(" ")){jt6.setText(jt7.getText());jt7.setText(" ");if(jt6.getText().equals("消费者1")) {bun4.setEnabled(false);bun5.setEnabled(true);bun6.setEnabled(true);}else if(jt6.getText().equals("消费者2")) {bun4.setEnabled(true);bun5.setEnabled(false);bun6.setEnabled(true);}else{bun4.setEnabled(true);bun5.setEnabled(true);bun6.setEnabled(false);}}else{if(jt6.getText().equals("消费者1")){bun4.setEnabled(true);bun5.setEnabled(false);bun6.setEnabled(false);}else if(jt6.getText().equals("消费者2")){bun4.setEnabled(false);bun5.setEnabled(true);bun6.setEnabled(false);}else{bun4.setEnabled(false);bun5.setEnabled(false);bun6.setEnabled(true);}jt6.setText(jt7.getText());jt7.setText(jt8.getText());jt8.setText(" ");}}}else if(bun==bun4){ if(jt1.getText().equals(" ")){if(jt6.getText().equals(" ")){jt6.setText(bun4.getText());bun4.setEnabled(false);}else if(jt7.getText().equals(" ")){jt7.setText(bun4.getText());bun4.setEnabled(false);}else if(jt8.getText().equals(" ")){jt8.setText(bun4.getText());bun4.setEnabled(false);}}elseif(jt2.getText().equals(" ")){jt1.setText(" ");}else if(jt3.getText().equals(" ")&jt4.getText().equals(" ")&jt5.getText().equals(" ")){ jt1.setText(jt2.getText());jt2.setText(" ");}else if(jt4.getText().equals(" ")&jt5.getText().equals(" ")){jt1.setText(jt2.getText());jt2.setText(jt3.getText());jt3.setText(" ");bun1.setEnabled(true);bun2.setEnabled(true);bun3.setEnabled(true);}else if(jt5.getText().equals(" ")){jt1.setText(jt2.getText());jt2.setText(jt3.getText());jt3.setText(jt4.getText());jt4.setText(" ");if(jt3.getText().equals("生产者1")) {bun1.setEnabled(false);bun2.setEnabled(true);bun3.setEnabled(true);}else if(jt3.getText().equals("生产者2")) {bun1.setEnabled(true);bun2.setEnabled(false);bun3.setEnabled(true);}else{bun1.setEnabled(true);bun2.setEnabled(true);bun3.setEnabled(false);}}else{jt1.setText(jt2.getText());jt2.setText(jt3.getText());jt3.setText(jt4.getText());jt4.setText(jt5.getText());jt5.setText(" ");if(jt2.getText().equals("生产者1")) {bun1.setEnabled(true);bun2.setEnabled(false);bun3.setEnabled(false);}else if(jt2.getText().equals("生产者2")) {bun1.setEnabled(false);bun2.setEnabled(true);bun3.setEnabled(false);}else{bun1.setEnabled(false);bun2.setEnabled(false);bun3.setEnabled(true);}}}else if(bun==bun5){ if(jt1.getText().equals(" ")){if(jt6.getText().equals(" ")){jt6.setText(bun5.getText());bun5.setEnabled(false);}else if(jt7.getText().equals(" ")){jt7.setText(bun5.getText());bun5.setEnabled(false);}else if(jt8.getText().equals(" ")){jt8.setText(bun5.getText());bun5.setEnabled(false);}}elseif(jt2.getText().equals(" ")){jt1.setText(" ");}else if(jt3.getText().equals(" ")&jt4.getText().equals(" ")&jt5.getText().equals(" ")){ jt1.setText(jt2.getText());jt2.setText(" ");}else if(jt4.getText().equals(" ")&jt5.getText().equals(" ")){jt1.setText(jt2.getText());jt2.setText(jt3.getText());jt3.setText(" ");bun1.setEnabled(true);bun2.setEnabled(true);bun3.setEnabled(true);}else if(jt5.getText().equals(" ")){jt1.setText(jt2.getText());jt2.setText(jt3.getText());jt3.setText(jt4.getText());jt4.setText(" ");if(jt3.getText().equals("生产者1")){bun1.setEnabled(false);bun2.setEnabled(true);bun3.setEnabled(true);}else if(jt3.getText().equals("生产者2")){bun1.setEnabled(true);bun2.setEnabled(false);bun3.setEnabled(true);}else{bun1.setEnabled(true);bun2.setEnabled(true);bun3.setEnabled(false);}}else{jt1.setText(jt2.getText());jt2.setText(jt3.getText());jt3.setText(jt4.getText());jt4.setText(jt5.getText());jt5.setText(" ");if(jt2.getText().equals("生产者1")){bun1.setEnabled(true);bun2.setEnabled(false);bun3.setEnabled(false);}else if(jt2.getText().equals("生产者2")){bun1.setEnabled(false);bun2.setEnabled(true);bun3.setEnabled(false);}else{bun1.setEnabled(false);bun2.setEnabled(false);bun3.setEnabled(true);}}}else if(bun==bun6){ if(jt1.getText().equals(" ")){if(jt6.getText().equals(" ")){jt6.setText(bun6.getText());bun6.setEnabled(false);}else if(jt7.getText().equals(" ")){jt7.setText(bun6.getText());bun6.setEnabled(false);}else if(jt8.getText().equals(" ")){jt8.setText(bun6.getText());bun6.setEnabled(false);}}elseif(jt2.getText().equals(" ")){jt1.setText(" ");}else if(jt3.getText().equals(" ")&jt4.getText().equals(" ")&jt5.getText().equals(" ")){ jt1.setText(jt2.getText());jt2.setText(" ");}else if(jt4.getText().equals(" ")&jt5.getText().equals(" ")) {jt1.setText(jt2.getText());jt2.setText(jt3.getText());jt3.setText(" ");bun1.setEnabled(true);bun2.setEnabled(true);bun3.setEnabled(true);}else if(jt5.getText().equals(" ")){jt1.setText(jt2.getText());jt2.setText(jt3.getText());jt3.setText(jt4.getText());jt4.setText(" ");if(jt3.getText().equals("生产者1")){bun1.setEnabled(false);bun2.setEnabled(true);bun3.setEnabled(true);}else if(jt3.getText().equals("生产者2")){bun1.setEnabled(true);bun2.setEnabled(false);bun3.setEnabled(true);}else{bun1.setEnabled(true);bun2.setEnabled(true);bun3.setEnabled(false);}}else{jt1.setText(jt2.getText());jt2.setText(jt3.getText());jt3.setText(jt4.getText());jt4.setText(jt5.getText());jt5.setText(" ");if(jt2.getText().equals("生产者1")){bun1.setEnabled(true);bun2.setEnabled(false);bun3.setEnabled(false);}else if(jt2.getText().equals("生产者2")){bun1.setEnabled(false);bun2.setEnabled(true);bun3.setEnabled(false);}else{bun1.setEnabled(false);bun2.setEnabled(false);bun3.setEnabled(true);}}}}}五、实验结果运行程序,显示如下:。

生产者消费者实验报告.doc

生产者消费者实验报告.doc

生产者消费者实验报告实验二.生产者与消费者进程实验报告实验目的:利用Windows提供的API函数,编写程序,解决生产者与消费者问题,实现进程的互斥与同步。

实验内容与步骤:1.进程的互斥与同步。

编写一段程序,模拟生产者和消费者线程,实现进程的互斥与同步。

2.利用VC++6.0实现上述程序设计和调试操作,对于生产者和消费者线程操作的成功与否提供一定的提示框。

3.通过阅读和分析实验程序,熟悉进程的互斥与同步的概念。

程序设计思路:关于这个生产者与消费者进程,我主要设计了两个线程,一个生产者线程,一个消费者线程。

整个进程随着这两个线程的创建,运行,终止而进行。

在程序的开始,首先我创建了一个结构struct,它包括的基本数据有:生产物品缓冲区(用队列来表示),一个标志缓冲区空间多少的信号量m_S_Empty,一个标志缓冲区已有物品多少的信号量m_S_Full,一个互斥信号量m_M_Mutex防止生产者与消费者同时访问缓冲区间,一个判断生产者是否要结束生产的bool类型标志producerfinished,若为true,则两个线程都终止。

进入主程序以后,首先对这些struct中的基本数据进行一个个赋值,然后创建生产者与消费者两个线程,等待两个线程都结束时,关闭进程。

要知道在main 主函数中两个线程的创建语句就是对两个线程各自进入函数的运行,生产者函数中通过一个for循环,可以控制生产者进行多次生产,不是生产一次就结束了。

消费者函数中通过一个while循环,当生产者没有结束生产时可以控制消费者进行多次消费,不是消费一次就不会再来消费了,除非生产者已结束生产,即producerfinished的值变为true。

实验主要程序及注释:#include "stdafx.h"#include #include #include #include using namespace std;DWORD WINAPI Consumer(void*);//声明消费者函数DWORD WINAPI Producer(void*);//声明生产者函数#define N 10//定义缓冲区数量/*数据结构的定义*/struct MyData{HANDLE m_S_Empty;// 生产者SemaphoreHANDLE m_S_Full; // 消费者SemaphoreHANDLE m_M_Mutex;//互斥信号量queue food; //定义共享缓冲区bool producerfinished;//标志着生产者是否结束生产};int j=0;//只是为了输出方便观察线程执行次数int main(){ /*对各个信号量赋值*/MyData mydata;//创建一个MyData数据类型的实体mydatamydata.m_M_Mutex = CreateMutex(NULL, false, NULL);//"false"表示刚刚创建的这个信号量不属于®¨²任何线程mydata.m_S_Empty = CreateSemaphore(NULL, N, N, NULL);//初始计数为N mydata.m_S_Full = CreateSemaphore(NULL, 0, N, NULL);//初始计数为0mydata.producerfinished=false;//-利用Windows提供的API 函数,编写程序,解决生产者与消费者问题,实现进程的互斥与同步。

生产者与消费者问题实验报告

生产者与消费者问题实验报告

生产者与消费者问题实验报告生产者与消费者问题实验报告篇一:生产者和消费者问题实验报告实验报告课程名称:操作系统实验名称:生产者和消费者问题学号:学生姓名:班级:指导教师:评分:实验日期:XX年 10月 22 日篇二:操作系统实验报告经典的生产者—消费者问题实验二经典的生产者—消费者问题一、目的实现对经典的生产者—消费者问题的模拟,以便更好的理解经典进程同步问题。

二、实验内容及要求编制生产者—消费者算法,模拟一个生产者、一个消费者,共享一个缓冲池的情形。

1、实现对经典的生产者—消费者问题的模拟,以便更好的理解此经典进程同步问题。

生产者-消费者问题是典型的PV操作问题,假设系统中有一个比较大的缓冲池,生产者的任务是只要缓冲池未满就可以将生产出的产品放入其中,而消费者的任务是只要缓冲池未空就可以从缓冲池中拿走产品。

缓冲池被占用时,任何进程都不能访问。

2、每一个生产者都要把自己生产的产品放入缓冲池,每个消费者从缓冲池中取走产品消费。

在这种情况下,生产者消费者进程同步,因为只有通过互通消息才知道是否能存入产品或者取走产品。

他们之间也存在互斥,即生产者消费者必须互斥访问缓冲池,即不能有两个以上的进程同时进行。

三、生产者和消费者原理分析在同一个进程地址空间内执行两个线程。

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

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

当生产者线程生产物品时,如果没有空缓冲区可用,那么生产者线程必须等待消费者线程释放一个空缓冲区。

当消费者线程消费物品时,如果没有满的缓冲区,那么消费者线程将被阻挡,直到新的物品被生产出来。

四、生产者与消费者功能描述:生产者功能描述:在同一个进程地址空间内执行两个线程。

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

当生产者线程生产物品时,如果没有空缓冲区可用,那么生产者线程必须等待消费者线程释放出一个空缓冲区。

生产者消费者问题实验报告

生产者消费者问题实验报告

生产者消费者问题实验报告生产者消费者问题实验报告一、引言生产者消费者问题是计算机科学中一个经典的并发问题,主要涉及到多个线程之间的协作和资源的共享。

在本实验中,我们通过编写一个简单的程序来模拟生产者和消费者之间的交互过程,以深入理解该问题的本质和解决方案。

二、问题描述在生产者消费者问题中,有两类线程:生产者和消费者。

生产者线程负责生产一定数量的产品,而消费者线程则负责消费这些产品。

两类线程需要共享一个有限的缓冲区,生产者将产品放入缓冲区,而消费者从缓冲区中取出产品。

然而,缓冲区的容量是有限的,当缓冲区已满时,生产者需要等待,直到有空间可用。

同样地,当缓冲区为空时,消费者需要等待,直到有产品可用。

三、实验设计为了解决生产者消费者问题,我们采用了经典的解决方案——使用互斥锁和条件变量。

互斥锁用于保护共享资源的访问,保证同一时间只有一个线程可以访问共享资源。

而条件变量用于线程之间的通信,当某个条件不满足时,线程可以通过条件变量进入等待状态,直到条件满足时再被唤醒。

在我们的程序中,我们使用了一个有界缓冲区来模拟生产者消费者之间的交互。

缓冲区的大小可以通过参数进行设置。

我们创建了两个线程分别代表生产者和消费者,它们通过互斥锁和条件变量来实现同步。

生产者线程在缓冲区未满时将产品放入缓冲区,并通知消费者线程有产品可用;消费者线程在缓冲区非空时从缓冲区取出产品,并通知生产者线程有空间可用。

通过这种方式,我们保证了生产者和消费者之间的协作和资源的共享。

四、实验结果经过多次运行实验,我们观察到了以下现象:当生产者线程的生产速度大于消费者线程的消费速度时,缓冲区会被生产者填满,消费者需要等待;当消费者线程的消费速度大于生产者线程的生产速度时,缓冲区会被消费者清空,生产者需要等待。

只有当生产者和消费者的速度相等时,才能实现平衡的生产和消费。

此外,我们还发现在某些情况下,生产者和消费者线程可能出现死锁或饥饿现象。

死锁是指两个或多个线程相互等待对方释放资源,导致程序无法继续执行的情况。

生产消费系统实验报告(3篇)

生产消费系统实验报告(3篇)

第1篇一、实验目的1. 加深对进程概念的理解,明确进程和程序的区别。

2. 进一步认识并发执行的实质。

3. 验证用信号量机制实现进程互斥的方法。

4. 验证用信号量机制实现进程同步的方法。

二、实验环境1. 操作系统:Windows 102. 编程语言:C语言3. 开发工具:Visual Studio三、实验内容1. 生产者和消费者模型介绍生产者和消费者模型是操作系统中常见的一种并发控制模型,用于解决多个进程之间的同步和互斥问题。

在该模型中,生产者负责生成数据,消费者负责消费数据。

生产者和消费者通过共享资源(如缓冲区)进行通信。

2. 实验设计(1)环形缓冲区为了实现生产者和消费者的同步,我们设计了一个环形缓冲区,由若干个大小相等的缓冲块组成。

每个缓冲块可以容纳一个产品。

环形缓冲区的指针分别指向当前的第一个空缓冲块和第一个满缓冲块。

(2)信号量为了实现进程互斥和同步,我们使用了三个信号量:① 公用信号量:用于实现临界区互斥,初始值为1。

② 生产者私用信号量:用于实现生产者与消费者之间的同步,初始值为0。

③ 消费者私用信号量:用于实现生产者与消费者之间的同步,初始值为0。

(3)生产者进程生产者进程负责生成数据,并将数据存入环形缓冲区。

当环形缓冲区满时,生产者进程等待;当环形缓冲区有空位时,生产者进程继续生成数据。

(4)消费者进程消费者进程负责从环形缓冲区中取出数据并消费。

当环形缓冲区空时,消费者进程等待;当环形缓冲区有数据时,消费者进程继续消费数据。

3. 实验步骤(1)创建生产者进程和消费者进程。

(2)初始化信号量。

(3)运行生产者进程和消费者进程。

(4)按任意键停止程序,显示当前系统的各个参数的值。

四、实验结果与分析1. 实验结果通过运行实验程序,我们可以观察到生产者和消费者进程的运行情况。

当按下任意键停止程序时,程序将显示当前系统的各个参数的值,包括环形缓冲区的空位数量、生产者和消费者的状态等。

2. 分析(1)互斥:通过公用信号量实现生产者和消费者对环形缓冲区的互斥访问,防止了同时操作缓冲区的问题。

生产者与消费者实验报告

生产者与消费者实验报告

生产者和消费者实验报告【实验目的】1.加深对进程概念的理解,明确进程和程序的区别。

2.进一步认识并发执行的实质。

3.验证用信号量机制实现进程互斥的方法。

4.验证用信号量机制实现进程同步的方法。

【实验要求】用c语言编程搭建“生产者和消费者”经典进程通信问题的环境。

要求程序运行时,按任意键停止,显示当前系统的各个参数的值。

提交实验报告,以及相关程序列表。

打包成附件上传。

【实验环境】Visual C++6.0【实验内容】1.了解经典同步问题“生产者和消费者”生产者与消费者可以通过一个环形缓冲池联系起来,环形缓冲池由几个大小相等的缓冲块组成,每个缓冲块容纳一个产品。

每个生产者可不断地每次往缓冲池中送一个生产产品,而每个消费者则可不断地每次从缓冲池中取出一个产品。

指针i和指针j分别指出当前的第一个空缓冲块和第一个满缓冲块。

2.分析和理解(1)既存在合作同步问题,也存在临界区互斥问题合作同步:当缓冲池全满时,表示供过于求,生产者必须等待,同时唤醒消费者;当缓冲池全空时,表示供不应求,消费者应等待,同时唤醒生产者。

互斥:缓冲池显然是临界资源,所在生产者与消费都要使用它,而且都要改变它的状态。

(2)基于环形缓冲区的生产者与消费者关系形式描述:公用信号量mutex:初值为1,用于实现临界区互斥生产者私用信号量empty:初值为n,指示空缓冲块数目消费者私用信号量full:初值为0,指示满缓冲块数目整型量i和j初值为0,i指示首空缓冲块序号,j指示首满缓冲块序号(3)PV原语var mutex,empty,full:semaphore;i,j:integer;buffer:array[0...n-1] of item;i:=j:=1;Procedure producer;beginwhile true dobeginproduce a product;P(empty);P(mutex);buffer(i):=product;i:=(i+1) mod n;V(mutex);V(full);end;end;Procedure consumer;beginP(full);P(mutex);goods:=buffer(j);j:=(j+1) mod n;V(mutex);V(empty);consume a product;end;end;【实验源程序代码】#include <windows.h>#include <iostream>const unsigned short SIZE_OF_BUFFER = 10; //缓冲区长度unsigned short ProductID = 0; //产品号unsigned short ConsumeID = 0; //将被消耗的产品号unsigned short in = 0; //产品进缓冲区时的缓冲区下标unsigned short out = 0; //产品出缓冲区时的缓冲区下标int g_buffer[SIZE_OF_BUFFER]; //缓冲区是个循环队列bool g_continue = true; //控制程序结束HANDLE g_hMutex; //用于线程间的互斥HANDLE g_hFullSemaphore; //当缓冲区满时迫使生产者等待HANDLE g_hEmptySemaphore; //当缓冲区空时迫使消费者等待DWORD WINAPI Producer(LPVOID); //生产者线程DWORD WINAPI Consumer(LPVOID); //消费者线程int main(){//创建各个互斥信号g_hMutex = CreateMutex(NULL,FALSE,NULL);g_hFullSemaphore =CreateSemaphore(NULL,SIZE_OF_BUFFER-1,SIZE_OF_BUFFER-1,NULL);g_hEmptySemaphore =CreateSemaphore(NULL,0,SIZE_OF_BUFFER-1,NULL);//调整下面的数值,可以发现,当生产者个数多于消费者个数时,//生产速度快,生产者经常等待消费者;反之,消费者经常等待const unsigned short PRODUCERS_COUNT = 3; //生产者的个数const unsigned short CONSUMERS_COUNT = 1; //消费者的个数//总的线程数const unsigned short THREADS_COUNT =PRODUCERS_COUNT+CONSUMERS_COUNT;HANDLE hThreads[PRODUCERS_COUNT]; //各线程的handleDWORD producerID[CONSUMERS_COUNT]; //生产者线程的标识符DWORD consumerID[THREADS_COUNT]; //消费者线程的标识符//创建生产者线程for (int i=0;i<PRODUCERS_COUNT;++i){hThreads[i]=CreateThread(NULL,0,Producer,NULL,0,&producerID[i]);if (hThreads[i]==NULL) return -1;}//创建消费者线程for (i=0;i<CONSUMERS_COUNT;++i){hThreads[PRODUCERS_COUNT+i]=CreateThread(NULL,0,Consumer,NULL,0,&con sumerID[i]);if (hThreads[i]==NULL) return -1;}while(g_continue){if(getchar()){ //按回车后终止程序运行g_continue = false;}}return 0;}//生产一个产品。

操作系统之进程(生产者---消费者)实验报告

操作系统之进程(生产者---消费者)实验报告

操作系统实验报告——生产者和消费者问题姓名:学号:班级:一、实验内容1、模拟操作系统中进程同步和互斥;2、实现生产者和消费者问题的算法实现;二、实验目的1、熟悉临界资源、信号量及PV操作的定义与物理意义;2、了解进程通信的方法;3、掌握进程互斥与进程同步的相关知识;4、掌握用信号量机制解决进程之间的同步与互斥问题;5、实现生产者-消费者问题,深刻理解进程同步问题;三、实验题目在Windows操作系统下用C语言实现经典同步问题:生产者—消费者,具体要求如下:(1)一个大小为10的缓冲区,初始状态为空。

(2)2个生产者,随机等待一段时间,往缓冲区中添加数据,若缓冲区已满,等待消费者取走数据之后再添加,重复10次。

页脚内容1(3)2个消费者,随机等待一段时间,从缓冲区中读取数据,若缓冲区为空,等待生产者添加数据之后再读取,重复10次。

四、思想本实验的主要目的是模拟操作系统中进程同步和互斥。

在系统进程并发执行异步推进的过程中,由于资源共享和进程间合作而造成进程间相互制约。

进程间的相互制约有两种不同的方式。

(1)间接制约。

这是由于多个进程共享同一资源(如CPU、共享输入/输出设备)而引起的,即共享资源的多个进程因系统协调使用资源而相互制约。

(2)直接制约。

只是由于进程合作中各个进程为完成同一任务而造成的,即并发进程各自的执行结果互为对方的执行条件,从而限制各个进程的执行速度。

生产者和消费者是经典的进程同步问题,在这个问题中,生产者不断的向缓冲区中写入数据,而消费者则从缓冲区中读取数据。

生产者进程和消费者对缓冲区的操作是互斥,即当前只能有一个进程对这个缓冲区进行操作,生产者进入操作缓冲区之前,先要看缓冲区是否已满,如果缓冲区已满,则它必须等待消费者进程将数据取出才能写入数据,同样的,消费者进程从缓冲区读取数据之前,也要判断缓冲区是否为空,如果为空,则必须等待生产者进程写入数据才能读取数据。

在本实验中,进程之间要进行通信来操作同一缓冲区。

操作系统生产者与消费者实验报告

操作系统生产者与消费者实验报告

实验报告第页专业_______软件工程_____ 班级_________ 学号_____ 姓名实验日期:年月日报告退发(订正、重做)课程实验名称生产者与消费者问题、读者—写者问题一、实验目的1. 实现生产者消费者问题模拟2. 进一步掌握P,V如何解决同步和互斥问题二、实验环境1. Windows或Linux平台2. Eclipse、Visual Studio 2005或GCC三、实验内容、步骤和结果分析实验内容:实现生产者消费者问题模拟,显示每次添加和读取数据时缓冲区的状态,生产者和消费者可用线程模拟。

1.一个大小为10的缓冲区,初始为空。

2. 五个生产者:若缓冲区可以加入数据,则示意进入生产过程(打印出生产者ID),往缓冲区添加数据,随机等待一段时间。

若缓冲区已满,等待消费者取走数据后再添加。

3. 五个消费者:若缓冲区可以读取数据,则示意进入消费过程(打印出消费者ID),从缓冲区读取数据,随机等待一段时间;若缓冲区为空,等待生产者添加数据后再读取。

四、讨论(说明实验过程中遇到的问题及解决办法;未解决/需进一步研讨的问题或建议新实验方法等)(请利用实验二中所给的各个版本信号量类来完成实验三。

若选用Windows平台,要求一定要选用这三个文件夹中的某个信号量类Semaphore来完成实验,否则实验报告视为缺交;若选用Linux平台,也要求参照已给出的三个版本的Semaphore类的接口,先定义一个Linux版本的C++类class Semaphore,并在该类基础上完成实验,提交实验报告时请附上自定义的Semaphore类。

读者—写者问题:#include<windows.h>#include"semaphore.h"#include"thread.h"#include<iostream>using namespace std;Semaphore rmutex(1);Semaphore wmutex(1);int count=0;unsigned int WINAPI Reader(void *p){while(TRUE){rmutex.P();count++;rmutex.V();if(count == 1)wmutex.P();cout << GetCurrentThreadId() << "reading the student's table"<<endl;rmutex.P();count--;rmutex.V();if(count == 0)wmutex.V();Sleep(rand()%1000);}}unsigned int WINAPI Writer(void *p){while(TRUE){wmutex.P();cout << GetCurrentThreadId() << "writting the student's table"<<endl;wmutex.V();Sleep(rand()%1000);}}int main(){HANDLE hThread[2];hThread[0] = startThread(Reader,NULL);hThread[1] = startThread(Writer,NULL);::WaitForMultipleObjects(2,hThread,TRUE,INFINITE);CloseHandle(hThread[0]);CloseHandle(hThread[1]);return 0;}生产者与消费者问题:#include<windows.h>#include"semaphore.h"#include"thread.h"#include<iostream>using namespace std;Semaphore full(5);Semaphore empty(5);Semaphore mutex(1);int count=0;unsigned int WINAPI Producer(void *p){while(TRUE){empty.P();mutex.P();cout << GetCurrentThreadId() << " produce!"<<endl;mutex.V();full.V();Sleep(rand()%1000);}}unsigned int WINAPI Consumer(void *p){while(TRUE){full.P();mutex.P();cout << GetCurrentThreadId() << " consum!"<<endl;mutex.V();empty.V();Sleep(rand()%1000);}}int main(){HANDLE hThread[2];hThread[0] = startThread(Producer,NULL);hThread[1] = startThread(Consumer,NULL);::WaitForMultipleObjects(2,hThread,TRUE,INFINITE);CloseHandle(hThread[0]);CloseHandle(hThread[1]); return 0;}。

四川大学操作系统课程设计第三次实验报告生产者和消费者

四川大学操作系统课程设计第三次实验报告生产者和消费者

实验报告(学生打印后提交)实验名称: 生产者和消费者问题实验时间: 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, 互斥量出现指打开互斥锁。

生产者-消费者操作系统实验报告

生产者-消费者操作系统实验报告

一、目的和要求在采用多道程序设计的系统中,往往有若干个进程并发执行。

进程之间存在相互制约关系,本实验模拟在单处理器情况下的进程并发执行过程中,如何利用信号量机制实现并发进程的同步和互斥,帮助学生加深了解信号量机制、进程的同步和互斥。

二、实验内容利用高级语言模拟生产者-消费者算法算法。

分析:本算法需要解决以下问题1、生产者和消费者不能同时进入缓冲池2、缓冲池已满时,生产者不能再投放3、缓冲池为空时,消费者不能消费问题解决方法1、使用互斥变量mutex,为1时,可以进入,为0不可进入,通过lock()和unlock()实现锁定和解锁2、通过数组pbuffer[n]和pnum[n]实现生产者队列,分别记录生产者的商品以及生产者序号。

生产者进程产生时判断队列是否有进程等待,当缓冲区满时,进入队列,出现空区时,队列优先进入。

3、通过数组cnum[n]实现消费者队列,用于记录消费者编号,消费者进程产生时判断队列是否有进程等待,当缓冲区空时,进入队列,出现非空时,队列优先进入。

三、算法设计与实现主流程图示:生产者功能流程图示:消费者功能流程图示:实验函数void main();void run();void jiance(int mutex);//判断当前缓冲区是否被占用void lock(int mutex);//将缓冲池锁定mutex置为1void unlock(int mutex);//释放缓冲池mutex置为0void producer();//生产者进程int pro();//生产者随机生产的产品int pisempty();//判断生产者队列是否为空int bisempty();//判断缓冲池的各个缓冲区是否都已经被填满void input(int pn,int nextp);//在生产者队列为空的条件下,进行放入缓冲池的操作void input2();//生产者队列不为空时,排队进入缓冲池void inpb(int pn,int nextp);//生产者队列为空时进入生产者队列void customer();//消费者进程int cisempty();//判断消费者队列是否为空void outb(int cn);//消费者队列为空时,进入消费者队列void output2();//消费者队列不为空时,排队消费产品void output(int cn);//取出缓冲池商品,进行消费的操作四、运行界面。

操作系统实验报告-生产者与消费者

操作系统实验报告-生产者与消费者

中南大学操作系统实验报告实验内容:Java多线程模拟生产者消费者问题实验时间:2014年5月指导老师:胡小龙老师姓名:代巍班级:信安1201班学号:**********一、实验目的对操作系统的整体进行一个模拟,通过实践加深对各个部分的管理功能的认识,还能进一步分析各个部分之间的联系,最后达到对完整系统的理解。

可以提高运用操作系统知识解决实际问题的能力;锻炼实际的编程能力,要达到以下要求。

(1)掌握进程(线程)的同步与互斥。

(2)掌握生产者消费者问题的实现方法。

(3)掌握多线程编程方法。

二、实验内容实现生产者消费者问题。

(1)假设循环缓冲队列共有多个缓冲单元。

(2)生产者线程的工作:生产出一个产品(即产生一个产品编号),按顺序往缓冲队列中“空”的缓冲单元放产品。

(3)消费者线程与的工作:从缓冲队列装有产品的缓冲单元中取出一个产品(即产品编号)。

(4)保证两个线程间的互斥和同步(5)在界面上打印缓冲队列的变化情况三、实验原理(1)生产者—消费者问题是一种同步问题的抽象描述。

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

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

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

模式还需要有一个缓冲区处于生产者和消费者之间,作为一个中介。

生产者把数据放入缓冲区,而消费者从缓冲区取出数据。

大概的结构如下图。

四、实验思想概述在操作系统中,线程有时被称为轻量级进程,是CPU使用的基本单位,它与属于同一进程的其他进程共享其他代码段、数据段和其他操作系统资源。

在Java中,线程的建立有两种方法:继承Thread类和实现Runnable接口。

其中,采用实现Runnable接口建立线程的好处是允许同时继承其他类从而实现多继承,并且在Java中,可采用synchronized或Object类的方法wait(),notify(),notifyAll()来实现多线程同步。

生产者与消费者实验报告(精品)

生产者与消费者实验报告(精品)

一、实验目的利用Windows提供的API函数,编写程序,解决生产者与消费者问题,实现进程的互斥与同步。

二、实验内容本实验要求设计在同一个进程地址空间内执行的两个线程。

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

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

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

生产者和消费者使用N个不同的缓冲区(N 为一个确定的数值,例如N=32)。

需要使用如下信号量:一个互斥信号量,用以阻止生产者线程和消费者线程同时操作缓冲区列表;一个信号量,当生产者线程生产出一个物品时可以用它向消费者线程发出信号;一个信号量,消费者线程释放出一个空缓冲区时可以用它向生产者线程发出信号;三、实验步骤1.创建信号量根据题目的要求,首先创建信号量。

本次实验共需使用三个信号量:一个用以阻止生产者线程和消费者线程同时操作缓冲区列表的互斥信号量,一个当生产者线程生产出一个物品时可以用它向消费者线程发出信号的信号量以及一个消费者线程释放出一个空缓冲区时可以用它向生产者线程发出信号的信号量。

使用Windows提供的CreateSemaphore函数和CreateMutex创建一个新的信号量。

CreateSemaphore函数原型:HANDLE CreateSemaphore{LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,LONG lInitialCount,LONG lMaximumCount,LPCTSTR lpName};如执行成功,返回信号量对象的句柄;零表示出错。

本程序所使用的该函数中各参数的解释:1.lpSemaphoreAttributesSECURITY_ATTRIBUTES,指定一个SECURITY_ATTRIBUTES结构,或传递零值,表示采用不允许继承的默认描述符。

生产者消费者实验报告

生产者消费者实验报告

河北建筑工程学院实验报告2013年11 月26 日班级物联网111姓名李望来学号37 评分实验台号同组人员实验名称进程同步课程名称操作系统仪器名称型号规格仪器编号Java Jdk1.6Eclipse eclipse-SDK-4.2.2一实验目的1.深刻理解进程同步的概念。

2.掌握经典同步问题,生产者——消费者问题。

二实验设备PC机三实验内容在java开发环境下模拟经典进程同步问题,生产者——消费者问题。

1. 设计方案:1、用Java编写程序,运行环境为Eclipse。

2、抽象化生产者与消费者之间的关系,即用进程来产生数据或者使用数据,定义的类有:(1)public class PCTable2(2)class Producer(3)class Consumer3、然后通过接口ActionListener来实现多个生产者与多个消费者之间的关系:(1)、class Producer implements ActionListener(2)、class Consumer implements ActionListener4、还需要有一个缓冲区来存放数据,即通过缓冲区把生产者和消费者联系起来。

2. 流程图:四 程序的主要代码package ch2;import java.awt.*;import java.awt.event.*; import javax.swing.*;public class PCTable2 {static JButton[] jbtn={new JButton("生产者1"),new JButton("生产者2"),new JButton("生产者3"),new JButton("生产者4"),new JButton("消费者1"),new JButton("消费者2"),new JButton("消费者3"),new JButton("消费者4")};static JPanel jpan1 = new JPanel(); static JPanel jpan2 = new JPanel(); static JPanel jpan3 = new JPanel();;创建“生产者”进程缓冲区是否阻塞“生产者”等待“消费者”取出缓冲区的数据创建“消费者”进程“消费者”阻塞缓冲区是否为空输入数据“生产者”生产产品后被唤醒NONOYESstatic JTextField jtf1 = new JTextField();static JTextField jtf2 = new JTextField();static JTextField jtf3 = new JTextField();static JTextField jtf4 = new JTextField();static JTextField jtf5 = new JTextField();static JTextField jtf6 = new JTextField();static JTextField jtf7 = new JTextField();public static void main(String[] args) {JFrame jfrm = new JFrame("生产者-消费者问题");jfrm.setBounds(300, 100,900,400);jfrm.setLayout(null);jpan1.setLayout(null);jpan2.setLayout(null);jpan3.setLayout(null);jtf1.setBounds(100,10,100,30);jtf2.setBounds(300,10,100,30);jtf3.setBounds(50,10,100,30);jtf4.setBounds(250,10,100,30);jtf5.setBounds(100,10,100,30);jtf6.setBounds(200,10,100,30);jtf7.setBounds(300,10,100,30);jpan1.setBounds(0,60,450,50);jpan2.setBounds(450,60,450,50);jpan3.setBounds(200,260,500,50);JLabel jlab1= new JLabel("消费者队列",JLabel.CENTER); jlab1.setBounds(600,30,100,30);jlab1.setOpaque(true);jlab1.setBackground(Color.yellow);JLabel jlab2= new JLabel("生产者队列",JLabel.CENTER); jlab2.setBounds(200,30,100,30);jlab2.setOpaque(true);jlab2.setBackground(Color.yellow);JLabel jlab3 = new JLabel("缓冲区",JLabel.CENTER);jlab3.setBounds(400,220,100,30);jlab3.setOpaque(true);jlab3.setBackground(Color.yellow);jbtn[0].setBounds(100,120,100,30);jbtn[1].setBounds(300,120,100,30);jbtn[2].setBounds(500,120,100,30);jbtn[3].setBounds(700,120,100,30);jbtn[4].setBounds(100,180,100,30);jbtn[5].setBounds(300,180,100,30);jbtn[6].setBounds(500,180,100,30);jbtn[7].setBounds(700,180,100,30);jbtn[0].addActionListener(new Producter());jbtn[1].addActionListener(new Producter());jbtn[2].addActionListener(new Producter());jbtn[3].addActionListener(new Producter());jbtn[4].addActionListener(new Consumer());jbtn[5].addActionListener(new Consumer());jbtn[6].addActionListener(new Consumer());jbtn[7].addActionListener(new Consumer());jpan1.add(jtf1);jpan1.add(jtf2);jpan2.add(jtf3);jpan2.add(jtf4);jpan3.add(jtf5);jpan3.add(jtf6);jpan3.add(jtf7); jfrm.add(jlab1);jfrm.add(jlab2);jfrm.add(jlab3);jfrm.add(jbtn[0]); jfrm.add(jbtn[1]);jfrm.add(jbtn[2]);jfrm.add(jbtn[3]);jfrm.add(jbtn[4]);jfrm.add(jbtn[5]);jfrm.add(jbtn[6]);jfrm.add(jbtn[7]);jfrm.add(jpan1);jfrm.add(jpan2);jfrm.add(jpan3);jtf1.setForeground(Color.BLUE);jtf2.setForeground(Color.BLUE);jtf3.setForeground(Color.BLUE);jtf4.setForeground(Color.BLUE);jtf5.setForeground(Color.BLUE);jtf6.setForeground(Color.BLUE);jtf7.setForeground(Color.BLUE);Font f=new Font("楷体",Font.BOLD,20);jtf1.setFont(f);jtf2.setFont(f);jtf3.setFont(f);jtf4.setFont(f);jtf5.setFont(f);jtf6.setFont(f);jtf7.setFont(f);jfrm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); jfrm.setVisible(true);}static class Producter implements ActionListener{JButton bun0=jbtn[0];JButton bun1=jbtn[1];JButton bun2=jbtn[2];JButton bun3=jbtn[3];JButton bun4=jbtn[4];JButton bun5=jbtn[5];JButton bun6=jbtn[6];JButton bun7=jbtn[7];public void actionPerformed(ActionEvent e) {JButton jbtn=(JButton)e.getSource();String str=jbtn.getText();if (jtf3.getText().equals("")){if (jtf5.getText().equals(""))jtf5.setText(str);else{if(jtf5.getText().equals("生产者1")||jtf5.getText().equals("生产者2")|| jtf5.getText().equals("生产者3")||jtf5.getText().equals("生产者4")){if(jtf6.getText().equals(""))jtf6.setText(str);else{if(jtf6.getText().equals("生产者1")||jtf6.getText().equals("生产者2")|| jtf6.getText().equals("生产者3")||jtf6.getText().equals("生产者4")) {if(jtf7.getText().equals(""))jtf7.setText(str);else{if(jtf1.getText().equals("")){jtf1.setText(str);jbtn.setEnabled(false);}elseif(jtf2.getText().equals("")){jtf2.setText(str);bun0.setEnabled(false);bun1.setEnabled(false);bun2.setEnabled(false);bun3.setEnabled(false);}}}}}}}else{jtf3.setText(jtf4.getText());jtf4.setText("");if(jtf4.getText().equals("")){if(jtf3.getText().equals(bun4.getText()))bun4.setEnabled(false);else bun4.setEnabled(true);if(jtf3.getText().equals(bun5.getText()))bun5.setEnabled(false);else bun5.setEnabled(true);if(jtf3.getText().equals(bun6.getText()))bun6.setEnabled(false);else bun6.setEnabled(true);if(jtf3.getText().equals(bun7.getText()))bun7.setEnabled(false);else bun7.setEnabled(true);}else{bun4.setEnabled(false);bun5.setEnabled(false);bun6.setEnabled(false);bun7.setEnabled(false);}}}}static class Consumer implements ActionListener{JButton bun0=jbtn[0];JButton bun1=jbtn[1];JButton bun2=jbtn[2];JButton bun3=jbtn[3];JButton bun4=jbtn[4];JButton bun5=jbtn[5];JButton bun6=jbtn[6];JButton bun7=jbtn[7];public void actionPerformed(ActionEvent e) {JButton jbtn=(JButton)e.getSource();String str=jbtn.getText();if (jtf5.getText().equals("")){if(jtf3.getText().equals("")){jtf3.setText(str);jbtn.setEnabled(false);}else{if(jtf4.getText().equals(""));{jtf4.setText(str);bun4.setEnabled(false);bun4.setEnabled(false);bun5.setEnabled(false);bun6.setEnabled(false);bun7.setEnabled(false);}}}else{jtf5.setText(jtf6.getText());jtf6.setText(jtf7.getText());jtf7.setText(jtf1.getText());jtf1.setText(jtf2.getText());jtf2.setText("");if(jtf1.getText().equals("")){bun0.setEnabled(true);bun1.setEnabled(true);bun2.setEnabled(true);bun3.setEnabled(true);}else{if(jtf2.getText().equals("")){if(jtf1.getText().equals(bun0.getText()))bun0.setEnabled(false);else bun0.setEnabled(true);if(jtf1.getText().equals(bun1.getText()))bun1.setEnabled(false);else bun1.setEnabled(true);if(jtf1.getText().equals(bun2.getText()))bun2.setEnabled(false);else bun2.setEnabled(true);if(jtf1.getText().equals(bun3.getText()))bun3.setEnabled(false);else bun3.setEnabled(true);}else{bun0.setEnabled(false);bun1.setEnabled(false);bun2.setEnabled(false);bun3.setEnabled(false);}}}}}}五实验结果这次生产者与消费者之间的关系的实验我用Java语言编写的,通过接口ActionListener用来将生产者进程与消费者进程实例化。

生产者消费者问题实验报告

生产者消费者问题实验报告

操作系统课程设计实验报告实验名称:生产者消费者问题姓名/学号:一、实验目的以生产者和消费者问题为例,学习Linux和Windows下进程通信、同步机制的具体实现方法,主要是信号量和共享内存。

熟悉相关系统API的用法。

二、实验内容使用共享内存和信号量机制来实现多个生产者/消费者进程间的通信和同步。

要求在Linux和Windows下分别实现。

缓冲区大小为3,初始为空。

2个生产者,随机等待一段时间,往缓冲区添加数据,重复6次。

3个消费者,重复4次。

三、实验环境Ubuntu 10.10 , GCC; Windows 7, VC 6.0;四、程序设计与实现1. Linux下:(1) 数据结构:a. 共享内存定义为一个结构,使得其数据成员更清晰且操作变得简单。

b. 共享缓冲区采用循环队列的数据结构,由上面的结构struct buf { int start; int end; int info[BUF_NUM]; }维护。

其中start为队头指针,end为队尾指针,info为数据区域。

(2) 算法:大致由三个模块组成:a.主程序(main):i.创建信号量、共享内存并进行初始化ii.创建生产者、消费者进程,生产者执行pro_fun(),消费者执行con_fun()iii.等待所有子进程的结束iv.删除信号量、共享内存b.生产者进程(pro_fun):i.通过key获得信号量、共享内存的ID,将内存添加到自己的地址空间ii.P(empty),P(mutex),Add(data),V(mutex),V(full)iii.解除和共享内存的关联c.消费者进程(con_fun):i.通过key获得信号量、共享内存的ID,将内存添加到自己的地址空间ii.P(full),P(mutex),Add(data),V(mutex),V(empty)iii.解除和共享内存的关联d.循环队列部分:加入数据:info[end] = value; end = (end + 1) % 3;取出数据:temp = info[start]; info[start] = 0; (start = start + 1)%3; return temp;(3) 程序流程图:a. 主函数:b. 生产者进程:c. 消费者进程和生产者类似4. Windows 下:(1) 数据结构:和Linux大致相同(2) 算法:a. 创建的子进程调用正在执行的文件本身,通过main函数的参数区分主进程和生产者、消费者进程。

生产者消费者问题实践报告问题建议

生产者消费者问题实践报告问题建议

生产者消费者问题实践报告问题建议下载温馨提示:该文档是我店铺精心编制而成,希望大家下载以后,能够帮助大家解决实际的问题。

此文下载后可定制随意修改,请根据实际需要进行相应的调整和使用。

并且,本店铺为大家提供各种各样类型的实用资料,如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等,如想了解不同资料格式和写法,敬请关注!Downloaded tips: This document is carefully compiled by the editor. I hope that after you download them, they can help you solve practical problems. The documents can be customized and modified after downloading, please adjust and use it according to actual needs, thank you!In addition, our shop provides you with various types of practical materials, such as educational essays, diary appreciation, sentence excerpts, ancient poems, classic articles, topic composition, work summary, word parsing, copy excerpts, other materials and so on, want to know different data formats and writing methods, please pay attention!在计算机科学领域,生产者消费者问题是一个经典的并发编程问题,涉及多个线程之间的协作和同步。

生产者和消费者问题实验报告

生产者和消费者问题实验报告

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

一、实验目的利用Windows提供的API函数,编写程序,解决生产者与消费者问题,实现进程的互斥与同步。

二、实验内容本实验要求设计在同一个进程地址空间内执行的两个线程。

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

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

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

生产者和消费者使用N个不同的缓冲区(N 为一个确定的数值,例如N=32)。

需要使用如下信号量:一个互斥信号量,用以阻止生产者线程和消费者线程同时操作缓冲区列表;一个信号量,当生产者线程生产出一个物品时可以用它向消费者线程发出信号;一个信号量,消费者线程释放出一个空缓冲区时可以用它向生产者线程发出信号;三、实验步骤1.创建信号量根据题目的要求,首先创建信号量。

本次实验共需使用三个信号量:一个用以阻止生产者线程和消费者线程同时操作缓冲区列表的互斥信号量,一个当生产者线程生产出一个物品时可以用它向消费者线程发出信号的信号量以及一个消费者线程释放出一个空缓冲区时可以用它向生产者线程发出信号的信号量。

使用Windows提供的CreateSemaphore函数和CreateMutex创建一个新的信号量。

CreateSemaphore函数原型:HANDLE CreateSemaphore{LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,LONG lInitialCount,LONG lMaximumCount,LPCTSTR lpName};如执行成功,返回信号量对象的句柄;零表示出错。

本程序所使用的该函数中各参数的解释:1.lpSemaphoreAttributesSECURITY_ATTRIBUTES,指定一个SECURITY_ATTRIBUTES结构,或传递零值,表示采用不允许继承的默认描述符。

该参数定义了信号量的安全特性。

2.lInitialCount设置信号量的初始计数。

可设置零到lMaximumCount之间的一个值。

3.lMaximumCount设置信号量的最大计数。

4.lpName指定信号量对象的名称。

可赋值为NULL。

CreateMutex函数原型:HANDLE CreateMutex{LPSECURITY_ATTRIBUTES lpMutexAttributes,BOOL bInitialOwner,LPCTSTR lpName};找出当前系统是否已经存在指定进程的实例。

如果没有则创建一个互斥体。

CreateMutex函数可用来创建一个有名或无名的互斥量对象。

本程序所使用的该函数中各参数的解释:1.lpMutexAttributes指定一个SECURITY_ATTRIBUTES结构,或传递零值表示使用不允许继承的默认描述符。

2.bInitialOwner如创建进程希望立即拥有互斥体,则设为TRUE。

一个互斥体同时只能由一个线程拥有。

3.lpName String指定互斥体对象的名字。

2.创建线程使用了Windows提供的CreateThread函数来创建一个在调用进程的地址空间中执行的线程。

函数原型HANDL CreateThread{LPSECURITY_ATTRIBUTES lpThreadAttributes,DWORD dwStackSize,LPTHREAD_START_ROUTINE lpStartAddress,LPVOID lpParameter,DWORD dwCreationFlags,LPDWORD lpThreadld};CreateThread将在主线程的基础上创建一个新线程,大致做如下步骤:1.在内核对象中分配一个线程标识/句柄,可供管理,由CreateThread返回;2.把线程退出码置为STILL_ACTIVE,把线程挂起计数置1;3.分配context结构,分配两页的物理存储以准备栈,保护页设置为PAGE_READWRITE,第2页设为PAGE_GUARD;4.lpStartAddr和lpvThread值被放在栈顶,使它们成为传送给StartOfThread的参数;5.把context结构的栈指针指向栈顶(第5步)指令指针指向startOfThread 函数。

本程序所使用的函数中各参数的解释:1.pThreadAttributes指向SECURITY_ATTRIBUTES型态的结构的指针。

初始化为NULL使用默认安全性,不可以被子线程继承,否则需要定义一个结构体将它的bInheritHandle 成员初始化为TRUE。

2.dwStackSize设置初始栈的大小,以字节为单位,如果初始值设为为0,那么默认将使用与调用该函数的线程相同的栈空间大小。

任何情况下,Windows根据需要动态延长堆栈的大小。

3.lpStartAddress指向线程函数的指针,形式:@函数名,函数名称没有限制,但是必须以下列形式声明:DWORD WINAPI 函数名 (LPVOID lpParam),格式不正确将无法调用成功。

4.lpParameter向线程函数传递的参数,是一个指向结构的指针,不需传递参数时,为NULL。

5.dwCreationFlags线程标志,可取值如下:(1)CREATE_SUSPENDED(0x00000004):创建一个挂起的线程,(2)0:表示创建后立即激活。

(3)STACK_SIZE_PARAM_IS_A_RESERVATION(0x00010000):dwStackSize参数指定初始的保留堆栈的大小,否则,dwStackSize指定提交的大小。

6.lpThreadId保存新线程的id。

当函数成功,返回线程句柄;函数失败返回false;若不想返回线程ID,设置值为NULL。

3.信号量的变化在程序的运行过程中必须动态改变第一步中设置的三个信号量的参数值。

使用的是Windows提供的WaitForSingleObject函数、ReleaseMutex函数和ReleaseSemaphore函数WaitForSingleObject函数原型DWORD WaitForSingleObject{HANDLE hHandle,DWORD dwMilliseconds};本程序所使用的函数中各参数的解释:1.hHandle对象句柄,可以指定一系列的对象,如Event、Job、Memory resource notification、Mutex、Process、Semaphore、Thread、Waitable timer等。

2.dwMilliseconds定时时间间隔,单位为milliseconds(毫秒).如果指定一个非零值,函数处于等待状态直到hHandle标记的对象被触发,或者时间到了。

如果dwMilliseconds为0,对象没有被触发信号,函数不会进入一个等待状态,它总是立即返回。

如果dwMilliseconds为INFINITE,对象被触发信号后,函数才会返回。

ReleaseMutex函数原型BOOL WIANPI ReleaseMutex{HANDLE hMutex};ReleaseMutex函数的功能是释放互斥对象的控制权。

返回TRUE表示成功,FALSE表示失败。

本程序所使用的函数中参数的解释:HANDLE hMutexHANDLE,制定一个互斥体的句柄。

ReleaseSemaphore函数原型BOOL ReleaseSemaphore{HANDLE hSemaphore,LONG lReleaseCount,LPLONG lpPreviousCount};ReleaseSemaphore函数用于对指定的信号量增加指定的值。

本程序所使用的函数中参数的解释:1.hSemaphore所要操作的信号量对象的句柄,这个句柄是CreateSemaphore或者OpenSemaphore函数的返回值且必须有SEMAPHORE_MODIFY_STATE的权限。

2.lReleaseCount信号量对象在当前基础上所要增加的值(必须大于0)。

如果信号量加上这个值会导致信号量的当前值大于信号量创建时指定的最大值,则信号量的当前值不变,同时这个函数返回FALSE。

3.lpPreviousCount指向返回信号量上次值的变量的指针,如果不需要信号量上次的值,那么这个参数可以设置为NULL。

四、系统截图图1 初始界面图2 生产者生产物品并显示缓冲区状态图3 消费者消耗物品并显示缓冲区状态五、遇到的问题及思考1、因为本程序允许有多个生产者和消费者存在,这就导致了一开始的结果中分不清到底是哪个生产者或消费者在工作,因此决定加上编号,但由于当时对CreateThread函数还不是很了解所以不知道如何传递参数,最后通过参考网上资料后得知CreateThread中的第四个参数lpParameter向线程函数传递的数值,在这里编号即可。

2、一开始无论如何修改程序(即使设置较长的时间断点),程序总会以“一个生产者一个消费者”这样的顺序运行。

这一点让我十分的疑惑,因为当我去掉消费者线程时,程序居然完成一个生产者的过程后停止。

经过思考后我发现问题出现在语句WaitForSingleObject(m_S_Empty, WaitTime) == WAIT_OBJECT_0,网上查阅资料后得知执行该语句则只有第一个线程被通知,因此事实上也只有完成了第一个生产者线程。

最后将该条语句换为WaitForSingleObject(m_S_Empty, WaitTime),这样所有的线程均被通知。

3、在程序运行时发现几个生产者线程提示信息缠在一起,经考虑后认定问题出在WaitTime的赋值上,需要较大的数值才能保证两个程序分开。

相关文档
最新文档