当前位置：文档之家 › 武汉理工大学--进程同步模拟设计-——吃水果问题

武汉理工大学--进程同步模拟设计-——吃水果问题

  • 格式：doc
  • 大小：232.00 KB
  • 文档页数：18

进程同步模拟设计 ——吃水果问题 1需求分析 吃水果问题的描述 桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。爸爸专门向盘子中放苹果，妈妈专门向盘子中放橘子，两个儿子专门等待吃盘子中的橘子，两个女儿专门等吃盘子中的苹果。 问题的转换

这是进程同步问题的模拟，可以把向盘子放或取水果的每一个过程可以转为一个进程的操作，这些进程是互斥的，同时也存在一定的同步关系。通过编程实践时，实际是随机的调用人一个进程的操作，而这些进程的操作相当于程序中的函数调用。而计算机在执行时每一个时刻只能执行一个操作，这就默认了互斥。同步的模拟可以类似于函数调用时的前提关系即先决条件。这样进程同步模拟就完全可以通过函数的调用来实现。 具体的每一个操作的对应的函数的关系： 爸爸向盘子中放一个苹果：Father() 妈妈向盘子中放一个橘子：Mother() 儿子1从盘子取一个橘子：Son1() 儿子2从盘子取一个橘子：Son2() 女儿1从盘子取一个苹果：Daugther1() 儿子1从盘子取一个苹果：Daugther2()

2功能设计 数据结构 (1)用一个整型变量Plate_Size表示盘子，初始值为0，当放水果时Plate_Size加1，取水果时Plate_Size减1。变量Plate_Size的最大值为2，当为2时表示盘子已经满，此时若进行放水果操作，放水果将处于等待状态；为0时表示盘子为空，此时若进行取水果操作，取水果操作将处于等待状态。 (2)整型变量orange和apple分别表示盘子中的橘子和苹果数目，初始都为0，Plate_Size=apple+orange。 (3)用6个bool型的变量 Father_lag，Mother_lag，Son1_lag，Son2_lag，Daughter1_lag，Daughter2_lag表示六个进程是否处于等待状态。处于等待时，变量值为true。 (4)两个放水果进程进程同时处于等待状态时，若有取水果的操作将自动执行等待的放水果进程，执行按等待的先后顺序；两个取苹果或橘子进程同时候处于等待状态，若有放苹果或橘子的操作将自动执行等待的取进程，进行按等待的先后顺序。 (5)用一个随机的函数产生0—5的6个整数，分别对应六个进程的调用。 模块说明

(1)main函数:用一个随机的函数产生0—5的6个整数，分别对应六个进程的调用，调用的次数可以自己输入，本程序共产生了10次随机的调用进程。 (2)6个进程函数:爸爸向盘子中放一个苹果操作：Father()；妈妈向盘子中放一个橘子操作：Mother()；儿子1从盘子取一个橘子操作：Son1()；儿子2从盘子取一个橘子操作：Son2()；女儿1从盘子取一个橘子操作：Daugther1()；女儿2从盘子取一个橘子操作：Daugther2()。 （3）Print函数：用于输出盘子中苹果和橘子的个数，水果总个数及有哪些进程处于等待状态。 操作的流程图

(1)放水果操作

爸爸放苹果进程的操作流程图：

(2)取水果操作

儿子1取橘子的操作流程图

Father操作： Plate_Size=否

否 Daugther1或Daugher2处是 按等待先后顺序调用

是 Father进程处于等待状Father进程调用：orange+1 Plate_Size+1,Print()函数

返回 3开发平台及源程序的主要部分 开发平台 （1）使用系统：windows7 （2）使用语言：C++ （3）开发工具：Microsoft Visual C++ 2012 Express 源程序主要部分

（1）Print函数（打印盘子剩余水果及各进程等待状态） void Print() { cout<<"现在盘子里有"<有"<

Son1操作： Plate_Size=否

否 Daugther1或Daugher2处是 按等待先后顺序调用

是 Father进程处于等待状Father进程调用：orange+1 Plate_Size+1,Print()函数

返回 if(Father_lag==true) cout<<"Father进程处于等待状态,"; if(Mother_lag==true) cout<<"Mother进程处于等待状态,"; if(Son1_lag==true) cout<<"Son1进程处于等待状态,"; if(Son2_lag==true) cout<<"Son2进程处于等待状态, "; if(Daughter1_lag==true) cout<<"Daughter1进程处于等待状态,"; if(Daughter2_lag==true) cout<<"Daughter2进程处于等待状态,"; if( ((Father_lag==false) &&(Mother_lag==false) &&(Son1_lag==false) &&(Son2_lag==false) &&(Daughter1_lag==false) &&(Daughter2_lag==false))!=true) cout<} （2）各进程调用的函数 void Father() { apple++; Print(); } void Mother(){ orange++; Print(); } void Son1() { orange--; Print(); } void Son2() { orange--; Print(); } void Daughter1() { apple--; Print(); } void Daughter2(){ apple--; Print(); } （3）主函数 void main() { int k; int i; int Plate_Size; int MonFa_c; int Son_a; srand((unsigned)time(NULL)); for(k=0;k<10;k++) { cout<<"***********************************"<<"第"<操 作"<<"***********************************"< i=rand()%6; Plate_Size=apple+orange; switch(i) { case 0: cout<<"Father调用."< if(Plate_Size==2) { Father_lag=true; Print(); if(Mother_lag==false) MonFa_c=1; } else { Father(); if((Daughter1_lag==true)&&(Daughter2_lag==true)) { if(Daughter_b==1) { Daughter1_lag=false; cout<<"处于等待的Daughter1自动被调用"< Daughter1(); Daughter_b=2; } else { Daughter2_lag=false; cout<<"处于等待的Daughter2自动被调用"< Daughter2(); Daughter_b=1; } } else { if(Daughter1_lag==true) { Daughter1_lag=false; cout<<"处于等待的Daughter1自动被调用"< Daughter1(); Daughter_b=0; } else if(Daughter2_lag==true) { Daughter2_lag=false； cout<<"处于等待的Daughter1自动被调用"< Daughter2(); Daughter_b=0; } } } break; case 1: cout<<"Mother调用."< if(Plate_Size==2) { Mother_lag=true; Print(); if(Father_lag==false) MonFa_c=2; } else { Mother(); if((Son1_lag==true)&&(Son2_lag==true)) { if(Son_a==1) { Son1_lag=false;

cout<<"处于等待的Son1自动被调用"<

Son1(); Son_a=2; } else { Son2_lag=false；

合集下载

操作系统课程设计—多进程同步橘子苹果问题源代码

操作系统课程设计—多进程同步橘子苹果问题源代码

操作系统课程设计—多进程同步橘子苹果问题源代码import ;import ;import ;import ;import ;import ;import java.awt.*;import ;import ;import ;import javax.swing.*;import ;public class Apple{/*** 生成一个缓冲池类对应的对象叫myStorage，以后所有的生产者线程和消费者线程都对这个myStorage对象进行操作！*/static MyStorage myStorage = new MyStorage();private JFrame window ;// 该数组用来存取生产橘子和苹果的线程，分别20个static Increaseapple[] appleincrease = new Increaseapple[20];static Increaseorange[] orangeincrease = new Increaseorange[20];// 该数组用来存放消费者线程，最多20个static Decreaseapple[] appledecrease = new Decreaseapple[20];static Decreaseorange[] orangedecrease = newDecreaseorange[20];// 代表两个生产者对应线程的数目，i1为苹果，i2为橘子static int i1 = 0;static int i2 = 0;// 代表消费者对应线程的数目,d1为苹果，d2为橘子static int d1 = 0;static int d2 = 0;static TextArea textArea1;static TextArea textArea2;static JProgressBar progressbar = new JProgressBar(0,20);static Draw draw1;static JTextField t1;static JTextField t2;static JTextField t3;static JTextField t4;public void createMainWindow(){window = new JFrame("橘子苹果问题");window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);window.setSize(700,700);window.setResizable(false);JPanel panel = new JPanel();panel.setLayout(null);JLabel App1 = new JLabel("生产苹果者数："); App1.setBounds(10, 500,100,25);panel.add(App1);progressbar.setStringPainted(true);progressbar.setBounds(200,640,300,30); panel.add(progressbar);progress p = new progress(myStorage);p.start();draw1 = new Draw(myStorage);draw1.setBounds(0,0,700,300);panel.add(draw1);t1 = new JTextField();t1.setBounds(120,500,60,25);t1.addKeyListener(new KeyAdapter(){public void keyTyped(KeyEvent event){char ch = event.getKeyChar();if (ch < '0' || ch > '9'){event.consume();}}});panel.add(t1);JButton inapp1 = new JButton("增加");inapp1.setBounds(190, 500, 60, 25);panel.add(inapp1);inapp1.addActionListener(new ActionListener() { @Overridepublic void actionPerformed(ActionEvent e) {if (i1 < 20){increaseappleProducer();t1.setText(String.valueOf(i1));}}});。

桌上有一空盘,最多允许存放一只水果

桌上有一空盘,最多允许存放一只水果

桌上有一空盘,最多允许存放一只水果.爸爸可向盘中放一个苹果或放一个桔子,儿子专问题描述：桌上有一空盘，最多允许存放一个水果。

爸爸可向盘中放一个苹果或放一个桔子，儿子专等吃盘中的桔子，女儿专等吃苹果。

试用P、V操作实现爸爸、儿子、女儿三个并发进程的同步。

问题分析及思路：1.这个话题就是生产者和消费者的扭曲，不是一个信号量就能解决的。

在这个问题中，父亲、儿子和女儿共用一个盘子，一次只能往盘子里放一个水果。

当盘子空了，父亲可以在盘子里放一个水果。

如果苹果放在采摘盘里，允许女儿吃，儿子要等。

如果橘子放在盘子里，儿子被允许吃，女儿必须等。

2.那么盘子就是一个缓冲(单缓冲)，同一时间只能有一个人放和拿。

所以这个盘子是互斥的。

但是当盘子里有苹果，父亲不放的时候，儿子可以拿，女儿也一样。

所以应该有两个资源信号量:1个苹果和2个橙子3.根据题意分析，三个信号量的初始值应该是1 0 0，因为桌子上只能放一个水果。

开始的时候桌子是空的(所以可以放)，所以苹果和橘子的初始资源是空的。

PV操作如下：int put=1,apple=0,orange=0;//定义同步信号量Father://父亲进程While(1){P(put);放一个苹果或者橘子;if(fruit==apple)V(apple);elseV(orange);}Daughter://女儿进程While(1){P(apple);拿一个苹果;V(put);吃苹果;}Son://儿子进程While(1){P(orange);拿一个桔子;V(put);吃桔子;}。

苹果-桔子问题的实现 (2)

苹果-桔子问题的实现 (2)

*******************实践教学*******************兰州理工大学计算机与通信学院2013年秋季学期操作系统原理课程设计题目：苹果-桔子问题的实现专业班级：计算机科学与技术姓名：学号：指导教师：王旭阳成绩：_____________本设计实际上是生产者-消费者问题的一种变形。

这里，生产者（父亲和母亲）放入缓冲区（盘子）的产品有两类（苹果和桔子），消费者（女儿和儿子）也有两类，每类消费者只消费其中固定的一类产品。

生产者和消费者共享缓冲区，缓冲区中有空时，生产者可放入产品（不许放重），否则等待。

缓冲区中有产品时，消费者可取出产品（不许取重），否则等待。

关键词：进程同步；PV操作；互斥；信号量摘要 (I)第一章需求分析 (1)1.1吃水果问题的描述 (1)1.2问题的转换 (1)第二章功能设计 (1)2.1 数据结构 (1)2.2模块说明 (2)2.2.1 主函数 (2)2.2.2 4个调度进程函数 (2)2.3 操作的流程图 (3)2．3．1放水果操作 (3)2．3．2取水果操作 (5)2.4 P、V原语的描述 (5)第3章各模块的伪码算法 (7)3.1 算法设计 (7)3.1.1 父亲进程模块 (7)3.1.2 母亲进程模块 (7)3.1.3 儿子进程模块 (8)3.1.5 Print函数 (8)第4章开发平台及程序清单的主要部分 (9)4.1开发平台 (9)第5章运行结果与运行情况分析 (10)5.1运行结果 (10)课程设计总结 (12)参考文献 (13)附录：部分源程序代码 (14)第一章需求分析1.1吃水果问题的描述桌上有一个空盘子，只允许放一个水果。

爸爸专向盘中放苹果，妈妈专向盘中放桔子，儿子专等吃盘中的桔子，女儿专等吃盘中的苹果。

规定当盘空时，一次只能放一个水果。

1.2问题的转换这是进程同步问题的模拟，可以把向盘子放或取水果的每一个过程可以转为一个进程的操作，这些进程是互斥的，同时也存在一定的同步关系。

进程同步模拟设计——哲学家就餐问题

进程同步模拟设计——哲学家就餐问题

进程同步模拟设计——哲学家就餐问题课程设计题⽬进程同步模拟设计—哲学家就餐学院计算机科学与技术专业计算机科学与技术班级计算机姓名指导教师20011 年 1 ⽉19 ⽇需求分析1.1问题描述有五个哲学家围坐在⼀圆桌旁，桌中央有⼀盘通⼼粉，每⼈⾯前有⼀只空盘⼦，每两⼈之间放⼀只筷⼦，即共5只筷⼦。

每个哲学家的⾏为是思考和进餐。

为了进餐，每个哲学家必须拿到两只筷⼦，并且每个⼈只能直接从⾃⼰的左边或右边去取筷⼦。

思考时则同时将两⽀筷⼦放回原处（此图中以叉⼦代表筷⼦）规则：只有拿到两只筷⼦时，哲学家才能吃饭；如果筷⼦已经在他⼈⼿上，则该哲学家必须等到他⼈吃完之后才能拿到筷⼦；任何⼀个哲学家在⾃⼰没有拿到两只筷⼦吃饭之前，决不放下⾃⼰⼿中的筷⼦。

由此出现的问题：可能出现死锁问题，因为当五个哲学家都饥饿时，都拿着⼀⽀筷⼦，这样就可能五个哲学家都⽤不上餐1.2问题分析该问题可⽤记录型信号量或者是AND型信号量解决。

记录型信号量解决：经分析可知，放在桌⼦上的筷⼦是临界资源，在⼀段时间内只允许⼀位哲学家使⽤，为了实现对筷⼦的互斥使⽤，可以⽤⼀个信号量表⽰⼀只筷⼦，由这五个信号量组成信号量数组。

当哲学家饥饿时总是先拿其左边的筷⼦，成功后，再去拿右边的筷⼦，⼜成功后⽅可就餐。

进餐完，⼜先放下他左边的筷⼦，再放下右边筷⼦。

这个算法可以保证不会有两个相邻的哲学家同时就餐，但有可能引起死锁。

AND型信号量解决：在哲学家就餐过程中，要求每个哲学家先获得两个临界资源后⽅能就餐，这在本质上就是AND同步问题，故⽤AND信号量机制可获得最简洁的解法。

1.3解决⽅法对于死锁问题可采取这样的⼏种解决⽅法：(1)⾄多只允许四个哲学家同时进餐，以保证⾄少有⼀个哲学家可以进餐，最终总会释放出他所⽤过的两只筷⼦，从⽽可使更多的哲学家进餐；(2)仅当左右两只筷⼦均可⽤时，才允许哲学家拿起筷⼦就餐(3)规定奇数号哲学家先拿起右边筷⼦，然后再去拿左边筷⼦，⽽偶数号哲学家则相反。