实验四模拟“五个哲学家”问题
哲学家就餐问题与银行家算法

问题解决
方法一
第一种解决死锁问题的办法就是同时只允许四位哲学家同时拿起同一 边的筷子,这样就能保证一定会有一位哲学家能够拿起两根筷子完成 进食并释放资源,供其他哲学家使用,从而实现永动,避免了死锁。 举个最简单的栗子,假定0~3号哲学家已经拿起了他左边的筷子,然后 当4号哲学家企图去拿他左边的筷子的时候,将该哲学家的线程锁住, 使其拿不到其左边的筷子,然后其左边的筷子就可以被3号哲学家拿到, 然后3号哲学家进餐,释放筷子,然后更多的哲学家拿到筷子并进餐。 如何才能实现当4号哲学家企图拿起其左边的筷子的时候将该哲学家 的线程阻塞?这个时候就要用到该问题的提出者迪杰斯特拉(这货还 提出了迪杰斯特拉最短路径算法,著名的银行家算法也是他发明的) 提出的信号量机制。因为同时只允许有四位哲学家同时拿起左筷子, 因此我们可以设置一个信号量r,使其初始值为4,然后每当一位哲学 家企图去拿起他左边的筷子的时候,先对信号量做一次P操作,从而当 第五位哲学家企图去拿做筷子的时候,对r做一次P操作,r = -1,由r < 0得第五位哲学家的线程被阻塞,从而不能拿起左筷子,因此也就避免 了死锁问题。然后当哲学家放下他左边的筷子的时候,就对r做一次V 操作。
死锁,但是处于不安全状态
哲学家进餐问题

哲学家进餐问题问题描述:有5个哲学家共用一张圆桌,分别坐在周围的5张椅子上。
在桌上有5支筷子和5个碗,他们的生活方式是交替的进行思考和进餐。
平时,一个哲学家进行思考,饥饿时便试图取用他左右最靠近他的筷子,只有在他拿到两只筷子时才能进餐。
进餐完毕放下筷子继续思考。
解决方法:1)至多只允许4位哲学家同时去拿他左边的筷子,最终能保证至少有一个哲学家能够进餐,并在用毕时能够释放他用过的两支筷子,从而使更多的哲学家能够进餐。
2)规定奇数号哲学家先拿他左边的筷子然后再拿右边的筷子;而偶数号哲学家则与此相反。
3)仅当哲学家的左右两边的筷子都能用时才允许他拿起筷子进餐。
用第3)种方法解决代码如下:#include <stdio.h>#include <stdlib.h>#include <windows.h>#include <time.h>#define PHILOSOPHERS 5HANDLE gchopStick[PHILOSOPHERS];DWORD WINAPI PhilosopherThread(LPVOID pVoid) {HANDLE myChopsticks[2];DWORD result;int iPhilosopher = (int) pVoid;int iLeftChopstick = iPhilosopher;int iRightChopstick = iLeftChopstick + 1;if (iRightChopstick > PHILOSOPHERS-1)iRightChopstick = 0;myChopsticks[0] = gchopStick[iLeftChopstick];myChopsticks[1] = gchopStick[iRightChopstick];result=WaitForMultipleObjects(2,myChopsticks,TR UE,-1);printf("the %d PHILOSOPHER begin to eat\n",iPhilosopher);Sleep(200);printf("the %d PHILOSOPHER finishedeating",iPhilosopher);ReleaseMutex(myChopsticks[0]);ReleaseMutex(myChopsticks[1]);return EXIT_SUCCESS;}int main(int argc,char *argv[]){DWORD dwThreadId,wait_for_all;HANDLE hThread[PHILOSOPHERS];for (int i=0; i < PHILOSOPHERS; i++){gchopStick[i] = CreateMutex(NULL, FALSE, NULL);}for (i = 0; i < PHILOSOPHERS; i++)hThread[i] = CreateThread(NULL, 0, PhilosopherThread, (LPVOID) i, 0, &dwThreadId);wait_for_all=WaitForMultipleObjects(PHILOSOPHER S,hThread,TRUE,-1);printf("All PHILOSOPHERs finished eating\n");return 0; }。
进程同步模拟设计——哲学家就餐问题

课程设计题目进程同步模拟设计—哲学家就餐学院计算机科学与技术专业计算机科学与技术班级计算机姓名指导教师20011 年 1 月19 日需求分析1.1问题描述有五个哲学家围坐在一圆桌旁,桌中央有一盘通心粉,每人面前有一只空盘子,每两人之间放一只筷子,即共5只筷子。
每个哲学家的行为是思考和进餐。
为了进餐,每个哲学家必须拿到两只筷子,并且每个人只能直接从自己的左边或右边去取筷子。
思考时则同时将两支筷子放回原处(此图中以叉子代表筷子)规则:只有拿到两只筷子时,哲学家才能吃饭;如果筷子已经在他人手上,则该哲学家必须等到他人吃完之后才能拿到筷子;任何一个哲学家在自己没有拿到两只筷子吃饭之前,决不放下自己手中的筷子。
由此出现的问题:可能出现死锁问题,因为当五个哲学家都饥饿时,都拿着一支筷子,这样就可能五个哲学家都用不上餐1.2问题分析该问题可用记录型信号量或者是AND型信号量解决。
记录型信号量解决:经分析可知,放在桌子上的筷子是临界资源,在一段时间内只允许一位哲学家使用,为了实现对筷子的互斥使用,可以用一个信号量表示一只筷子,由这五个信号量组成信号量数组。
当哲学家饥饿时总是先拿其左边的筷子,成功后,再去拿右边的筷子,又成功后方可就餐。
进餐完,又先放下他左边的筷子,再放下右边筷子。
这个算法可以保证不会有两个相邻的哲学家同时就餐,但有可能引起死锁。
AND型信号量解决:在哲学家就餐过程中,要求每个哲学家先获得两个临界资源后方能就餐,这在本质上就是AND同步问题,故用AND信号量机制可获得最简洁的解法。
1.3解决方法对于死锁问题可采取这样的几种解决方法:(1)至多只允许四个哲学家同时进餐,以保证至少有一个哲学家可以进餐,最终总会释放出他所用过的两只筷子,从而可使更多的哲学家进餐;(2)仅当左右两只筷子均可用时,才允许哲学家拿起筷子就餐(3)规定奇数号哲学家先拿起右边筷子,然后再去拿左边筷子,而偶数号哲学家则相反。
(4)把筷子顺序编号 fk0, fk1, fk2, fk3, fk4,给每个哲学家分配筷子时,必须依从小号到大号(或者相反顺序)进行。
操作系统实验报告(哲学家问题)

操作系统实验报告实验者:朱毅学号:0701013 实验题目:哲学家问题设有5个哲学家,共享一张放有5把椅子的桌子,每人分得一把椅子。
但是,桌子上总共只有5支筷子,在每人两边分开各放一支。
哲学家们在肚子饥饿时才试图分两次从两边拾起筷子就餐。
条件:(1)只有拿到两支筷子时,哲学家才能吃饭。
(2)如果筷子已在他人手上,则哲学家必须等他人吃完之后才能拿到筷子。
(3)任一哲学家在自己未拿到两支筷子吃饭之前,决不放下自己手中的筷子。
试:(1)描述一个保证不会出现两个邻座同时要求吃饭的通信算法。
(2)描述一个既没有两邻座同时吃饭,又没有人饿死(永远拿不到筷子)的算法。
(3)在什么情况下,5个哲学家全部吃不上饭?开发环境:Microsoft V isual Foxpro 6.0算法描述:数据环境:表KUAIZI 相应字段:筷子号状态(逻辑型)使用者桌号表ZHEXUEJIA相应字段:哲学家名所属状态拥有左筷子(逻辑型)拥有右筷子(逻辑型)桌号表FANGAN 相应字段方案表的具体内容请参见DAIMA.DOC文件本程序解决死锁的关键:从苏格拉底开始往黑格尔依次处理,对每人的处理一次进行到底,从而肯定必然有一人完全占有资源,避免了死锁,其实质就是按照5个哲学家的座位号作为绝对的优先级进行资源的先后分配。
初始状态:选择算法(以下两算法不同之处用黑体标识)算法一:(1)保证不会出现两个邻座同时要求吃饭的通信算法。
1、由操作人员按“有人饿了”按钮,控制是否有哲学家肚子饿了。
2、出现复选框和“确定”按钮,挑选哲学家后,按“确定”后确认选择。
当做出一个选择后,该哲学家左右两边的哲学家则不能被选中(通过对复选框的ENABLED属性控制),若取消选中,则该哲学家左右两边的哲学家(在该哲学家的另一邻居也未被选中为前提) 还原为可选状态。
3、“确认”后执行以下步骤:①从苏格拉底到黑格尔依次检验其是否是此次被选中②若是此次被选中,进行以下步骤:a 改变表KUAIZI 和表ZHEXUEJIA中相应的字段:ZHEXUEJIA:所属状态由F(Full)改为H(Hungry)b执行PROG1,分配给这些饥饿的哲学家筷子,若左边有筷子,取之,并标识“拥有左筷子”;若右边有筷子,取之,并标识“拥有右筷子”。
哲学家进餐问题

哲学家进餐问题2007/05/16 12:36 P.M./********************philosophers.cpp哲学家进餐问题在多线程中如何避免死锁。
问题描述:有五位哲学家围绕着餐桌坐,每一位哲学家要么思考要么等待,要么吃饭。
为了吃饭,哲学家必须拿起两双筷子(分别放于左右两端)不幸的是,筷子的数量和哲学家相等,所以每只筷子必须由两位哲学家共享下面是一种有问题的解法,因为在某个时刻,五个哲学家同时拿起五根左手边的筷子,则它们会在同一时候对待右手边的筷子,这样会陷入死锁,但是我测试了,这样的几率并不高经过几个小时,还没有出现。
但是我们可以肯定,理论上是肯定会出现死锁的,我们不能老是靠运气办事,怎么解决这个问题呢留给下一步的学习吧要编译此文件请用多线程版的c++库********************/#include <windows.h>#include <iostream>#include <process.h>#include <cstdlib>#include <ctime>using namespace std;unsigned int __stdcall philosopher(void *);void thinking(int);void eating(int);void wait_to_eat(int);void outline(int ,const char *);//全局变量CRITICAL_SECTION crout;//这个变量用来保证输出时不会竞争CRITICAL_SECTION fork[5];//定义五个临界变量,代表五更筷子int main(int argc,char *argv[]){void * hthread[5];int i;unsigned int threadid[5];int arg[5];int count = 5;unsigned long retval;InitializeCriticalSection(&crout);//初始化临界变量for(i=0;i<5;i++){InitializeCriticalSection(fork + i);}//创建五个哲学家for(i = 0; i<5;i++){arg[i] = i;hthread[i] = (void *)_beginthreadex(NULL,0,philosopher,(void *)(arg + i),0,threadid+i);if((int)hthread[i] == -1)//如果线程创建失败返回-1{cerr << "error while create thread " << i <<endl;cerr << "error code : "<< GetLastError() <<endl;}}//等待所有线程结束retval = WaitForMultipleObjects(5,hthread,true,INFINITE);//等待多个线程if(retval == WAIT_FAILED){cerr<< "wait error,error code: "<<GetLastError()<<endl;}for(i = 0; i<5;i++){if(CloseHandle(hthread[i]) == false)//关闭句柄{cerr << "error while close thread " <<i<<endl;cerr << "error code: "<<GetLastError()<<endl;}}return 0;}/*******************哲学家的行为吃饭,等待,思考*******************/unsigned int __stdcall philosopher(void *k){int n = ((int *)k)[0];outline(n," is in!");srand(time(NULL));while(true){thinking(n);wait_to_eat(n);eating(n);}outline(n," is out!");return n;}/*************思考随机一段时间*************/void thinking(int k){outline(k," is thinking...");Sleep((rand()%1000) *5);}/*************吃饭随机一段时间*************/void eating(int k){outline(k," is eating...");Sleep((rand()%1000) *5);LeaveCriticalSection(fork + (k+1)%5);//放下右边的筷子//outline(k," give left");LeaveCriticalSection(fork + k);//放下左边的筷子//outline(k," give right");}/***************等待吃饭需要同时获得他两边的筷子***************/void wait_to_eat(int k){outline(k," is waiting...");EnterCriticalSection(fork + k);//获得左边的筷子//outline(k," take left");EnterCriticalSection(fork + (k + 1)%5);//获得右边的筷子//outline(k," take right");}/********************//没有竞争条件的输出函数********************/void outline(int who,const char *str){EnterCriticalSection(&crout);cout<<"process "<<who<<str<<endl;LeaveCriticalSection(&crout);}/********************philosophers.cpp哲学家进餐问题在多线程中如何避免死锁。
哲学家进餐问题

哲学家进餐问题1.问题描述:哲学家进餐问题描述有五个哲学家,他们的生活方式是交替地进行思考和进餐,哲学家们共用一张圆桌,分别坐在周围的五张椅子上,在圆桌上有五个碗和五支筷子,平时哲学家进行思考,饥饿时便试图取其左、右最靠近他的筷子,只有在他拿到两支筷子时才能进餐,该哲学家进餐完毕后,放下左右两只筷子又继续思考。
约束条件(1)只有拿到两只筷子时,哲学家才能吃饭。
(2)如果筷子已被别人拿走,则必须等别人吃完之后才能拿到筷子。
(3)任一哲学家在自己未拿到两只筷子吃完饭前,不会放下手中已经拿到的筷子。
2.求解方法(1).信号量的设置放在桌子上的筷子是临界资源,在一段时间内只允许一位哲学家使用,为了实现对筷子的互斥访问,可以用一个信号量表示筷子,由这五个信号量构成信号量数组。
semaphore chopstick[5] = {1,1,1,1,1};while(true){/*当哲学家饥饿时,总是先拿左边的筷子,再拿右边的筷子*/wait(chopstick[i]);wait(chopstick[(i+1)%5]);// 吃饭/*当哲学家进餐完成后,总是先放下左边的筷子,再放下右边的筷子*/signal(chopstick[i]);signal(chopstick[(i+1)%5]);}上述的代码可以保证不会有两个相邻的哲学家同时进餐,但却可能引起死锁的情况。
假如五位哲学家同时饥饿而都拿起的左边的筷子,就会使五个信号量chopstick都为0,当他们试图去拿右手边的筷子时,都将无筷子而陷入无限期的等待。
(2)避免死锁策略一原理:至多只允许四个哲学家同时进餐,以保证至少有一个哲学家能够进餐,最终总会释放出他所使用过的两支筷子,从而可使更多的哲学家进餐。
定义信号量count,只允许4个哲学家同时进餐,这样就能保证至少有一个哲学家可以就餐。
semaphore chopstick[5]={1,1,1,1,1};semaphore count=4; // 设置一个count,最多有四个哲学家可以进来void philosopher(int i){while(true){think();wait(count); //请求进入房间进餐 当count为0时 不能允许哲学家再进来了wait(chopstick[i]); //请求左手边的筷子wait(chopstick[(i+1)%5]); //请求右手边的筷子eat();signal(chopstick[i]); //释放左手边的筷子signal(chopstick[(i+1)%5]); //释放右手边的筷子signal(count); //退出房间释放信号量}}策略二原理:仅当哲学家的左右两支筷子都可用时,才允许他拿起筷子进餐。
哲学家用餐问题

哲学家一(线程一函数)
读懂整 个程序。 请写出其余两个线程 的函数Thread2Proc 和 Thread3Proc ,使他们 都先取右边的筷子, 后取左边的筷子。执 行,写出实验结果或 现象。回答问题(3)
(2)描述一个既没有两座同时吃饭,又没有人饿死(永远拿 到到筷子)的算法。
• 对上面的程序Байду номын сангаас行改进,完成题目(2)要求。
选做题:
• 根据以前做过的实验,把算法移植到给定的图形用户界 面(GUI)框架程序中,每个线程创建自己的窗口,每个哲 学家的吃饭和取筷子信息显示在自己的窗口界面中,每 个窗口中右键单击时开始取筷子和吃饭的过程。 • 为降低图形化开发的难度,可以只设计三个哲学家线程, 每个线程设计自己的线程函数(即不合并线程函数)。 • 执行时以各种顺序在三个窗口中右击,验证执行结果。
• 思考:改变放下左右两边的筷子的顺序会有影 响吗?验证执行。
程序改进二: 把三个线程函数合并成一个统一的线程函数,哲学家的编号由 线程的函数参数传入,根据前面的程序代码完成省咯号处的设 计,并完成主函数的相应修改。执行,记录结果。
DWORD WINAPI ThreadProc( LPVOID lpParameter ) { int index; index=*(int *)lpParameter; …… return 0; } int main() { int num=1; h_Thread[0]=CreateThread(NULL,0 ,ThreadProc,&num ,0,NULL); num++; h_Thread[1]=CreateThread(NULL,0 ,ThreadProc,&num ,0,NULL); num++; h_Thread[2]=CreateThread(NULL,0 ,ThreadProc,&num ,0,NULL); }
哲学家就餐

哲学家就餐设有五个哲学家,共用一张放有五把椅子的餐桌,每人坐在一把椅子上,桌子上有五个碗和五只筷子,每人两边各放一只筷子。
哲学家们是交替思考和进餐,饥饿时便试图取其左右最靠近他的筷子。
条件:(1) 只有拿到两只筷子时,哲学家才能吃饭。
(2) 如果筷子已被别人拿走,则必须等别人吃完之后才能拿到筷子。
(3) 任意一个哲学家在自己未拿到两只筷子吃饭前,不会放下手中拿到的筷子。
总体设计思想哲学家的生活就是思考和吃饭,即思考,饿了就餐,再思考,循环往复。
要求是:每一个哲学家只有在拿到位于他左右的筷子后,才能够就餐;哲学家只能先拿左边的筷子,再去拿右边的筷子,而不能同时去抓他两边的筷子,也不能从其他哲学家手中抢夺筷子;哲学家每次就餐后必须放下他手中的两把筷子后恢复思考,不能强抓住餐具不放。
设计一个程序,能够显示当前各哲学家的状态和桌上餐具的使用情况,并能无死锁的推算出下一状态各哲学家的状态和桌上餐具的使用情况。
即设计一个能安排哲学家正常生活的程序用0-4五个数字代表五位哲学家,0-4五的数字代表筷子。
模拟该问题。
问题描述可能出现死锁问题,因为当五个哲学家都饥饿时,都拿着一支筷子,这样就可能五个哲学家都用不上餐。
解决方案1 最多允许4个哲学家同时坐在桌子周围。
2 给所有哲学家编号,奇数号的哲学家必须首先拿左边的筷子,偶数号的哲学家则反之。
3 为了避免死锁,把哲学家分为三种状态,思考,饥饿,进食,仅当一个哲学家左右两边的筷子都可用时,才允许他拿筷子,并且一次拿到两只筷子,否则不拿。
程序截图1.开始选择界面2.选择“死锁”,则哲学家会按照先拿左边筷子,再拿右边筷子,而放筷子的时候也是同样的,因而会出现死锁,即光标不停闪烁,而程序不在继续的结果,如图3.选择“没有死锁”的界面,则是通过前面的解决方案对资源进行优化后,这样程序不会出现死锁,会一直运行,如图程序源代码:#include <windows.h>#include <conio.h>#include <stdlib.h>#include <stdio.h>#include <time.h>#include <io.h>#include <string.h>#define MAX_PHILOSOPHERS 5 //待测试的哲学家数#define ZERO 48 //数字0的ASCII码#define DELAY rand()%25HANDLEh_mutex_chopsticks[MAX_PHILOSOPHERS]; //互斥体数组,每根筷子需要一个互斥体intthread_number[MAX_PHILOSOPHERS]={0,1,2,3,4};//会产生死锁的哲学家线程int deadlock_philosopher(LPVOID data){int philosopher_number=*(int *)(data); //哲学家编号for(;;){srand( (unsigned)time( NULL ) * ( philosopher_number+ 1) );Sleep(DELAY);printf("%s%c%s%c\n","哲学家",ZERO+philosopher_number," 正在等待筷子",(ZERO+philosopher_number));WaitForSingleObject(h_mutex_chopsticks[philosopher_num ber], INFINITE);printf("%s%c%s%c\n","哲学家",ZERO+philosopher_number," 得到筷子",(ZERO+philosopher_number));Sleep(DELAY/4);printf("%s%c%s%c\n","哲学家",ZERO+philosopher_number," 正在等待筷子",(ZERO+(1+philosopher_number)%MAX_PHILOSOPHER S));WaitForSingleObject(h_mutex_chopsticks[((1+philosopher_n umber)%MAX_PHILOSOPHERS)], INFINITE);printf("%s%c%s%c\n","哲学家",ZERO+philosopher_number," 得到筷子",(ZERO+(1+philosopher_number)%MAX_PHILOSOPHER S));printf("%s%c%s\n","哲学家",ZERO+philosopher_number," 正在就餐.");Sleep(DELAY);ReleaseMutex(h_mutex_chopsticks[philosopher_number]);printf("%s%c%s%c\n","哲学家",ZERO+philosopher_number," 放下筷子",ZERO+philosopher_number);ReleaseMutex(h_mutex_chopsticks[(1+philosopher_number) %MAX_PHILOSOPHERS]);printf("%s%c%s%c\n","哲学家",ZERO+philosopher_number," 放下筷子",(ZERO+(1+philosopher_number)%MAX_PHILOSOPHER S));Sleep(DELAY);} // end forreturn 0;}//死锁时的初始化程序void deadlock(){int i=0;HANDLE h_thread[MAX_PHILOSOPHERS];printf("可能出现死锁的哲学家就餐问题\n");for(i=0;i<MAX_PHILOSOPHERS;i++){h_mutex_chopsticks[i]=CreateMutex(NULL,FALSE,NULL);};for(i=0;i<MAX_PHILOSOPHERS;i++){h_thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ ROUTINE)(deadlock_philosopher),&thread_number[i],0,NU LL);};WaitForMultipleObjects(MAX_PHILOSOPHERS,h_t hread,TRUE,-1);}//通过资源预分配法预防死锁的哲学家线程int pre_alloction_philosopher(LPVOID data){int philosopher_number=*(int *)(data);HANDLE h_mutex_leftandright_chopsticks[2];h_mutex_leftandright_chopsticks[0]=h_mutex_chopsti cks[philosopher_number];h_mutex_leftandright_chopsticks[1]=h_mutex_chopsticks[(1+ philosopher_number)%MAX_PHILOSOPHERS];for(;;){srand( (unsigned)time( NULL ) * ( philosopher_number+ 1) );Sleep(DELAY);printf("%s%c%s%c\n","哲学家",ZERO+philosopher_number," 正在等待筷子",ZERO+philosopher_number);printf("%s%c%s%c\n","哲学家",ZERO+philosopher_number," 正在等待筷子",ZERO+(1+philosopher_number)%MAX_PHILOSOPHER S);WaitForMultipleObjects(2,h_mutex_leftandright_chopsticks, TRUE, INFINITE);printf("%s%c%s\n","哲学家",ZERO+philosopher_number," 正在就餐.");Sleep(DELAY);printf("%s%c%s%c\n","哲学家",ZERO+philosopher_number," 放下筷子",ZERO+philosopher_number);ReleaseMutex(h_mutex_chopsticks[philosopher_number]);printf("%s%c%s%c\n","哲学家",ZERO+philosopher_number," 放下筷子",ZERO+(1+philosopher_number)%MAX_PHILOSOPHER S);ReleaseMutex(h_mutex_chopsticks[(1+philosopher_number) %MAX_PHILOSOPHERS]);Sleep(DELAY);} // end forreturn 0;}//通过资源预分配法预防死锁的初始化程序void pre_alloction(){int i=0;HANDLE h_thread[MAX_PHILOSOPHERS];printf("可能出现死锁的哲学家就餐问题\n");for(i=0;i<MAX_PHILOSOPHERS;i++){h_mutex_chopsticks[i]=CreateMutex(NULL,FALSE,NULL);};for(i=0;i<MAX_PHILOSOPHERS;i++){h_thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ ROUTINE)(pre_alloction_philosopher),&thread_number[i],0 ,NULL);};WaitForMultipleObjects(MAX_PHILOSOPHERS,h_t hread,TRUE,-1);}//主程序int main(int argc,char *argv[]){char select;while(1){printf("|-------------------------------------------------------------|\n");printf("| 1:死锁|\n");printf("| 2:没有死锁|\n");printf("| 3:退出|\n");printf("|--------------------------------------------------------------|\n") ;printf("请选择(1~3):");do{select=(char)getch();}while(select!='1'&&select!='2'&&select!='3');system("cls");switch(select){case '1':deadlock();break;case '2':pre_alloction();break;case '3':return 0;}printf("\nPress any key to return to main menu.");getch();system("cls");}return 0;}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验四模拟"五个哲学家"问题
魏陈强学号:23020092204168
谢思发学号:23020092204174
一、实验题目:
哲学家就餐问题是一种典型的同步问题,它是由Dijkstra提出并解决的。
该问题描述如下:有五个哲学家围坐在一张圆形餐桌,交替做以下两件事:吃饭和思考。
餐桌中间有一碗意大利面,每两个哲学家之间只有一支餐叉,如果他们想吃面则必须使用其左右的两支餐叉。
显然每次最多只能有2个哲学家同时进餐,而且进餐过程有可能会产生死锁,如每个哲学家都拿着左手餐叉,等待右手餐叉。
从而导致五个哲学家无法进餐而饿死。
现需实验模拟解决哲学家进餐问题,使哲学家们能顺利的进餐思考。
二、算法分析:
该实验的要点是,解决并发环境下,多进程之间的同步与互斥问题。
进程间的同步互斥必然涉及进程间通信。
但是进程的内存空间是彼此隔离的,因此它们之间的通信只能通过如下手段:IPC机制、管道、信号或文件。
本次实验采用文件手段解决通信问题。
经验证如果哲学家中同时存在左撇子和右撇子,则哲学家问题有解。
模拟程序的框架如下所示:定义5个文件,分别表示5个叉子。
其文件名按如下方式说明:
Static char* forks[5]={"fork0","fork1","fork2","fork3","fork4"};
哲学家的行为可以用如下函数描述:
Void philosopher(int i)
{
while(1){
thinking(i,nsecs);
TakeFork(i);
eating(i,nsecs);
putFork(i);
}
}
在主程序里,可以用以下的程序段生成5个哲学家进程:
#define N 5
for(i=0;i<N;i++){
pid=fork();
If(pid==0)
philosopher(i);
}
wait(NULL);
拿起叉子可以如此定义:
void takeFork(i)
{
if(i==N-1){
lock(forks[0]);
lock(forks[i]);
else {
lock(forks[i]);
lock(forks[i+1]);
}
}
放下叉子可以如此定义:
void putFork(i)
{
if(i==N-1){
unclolck(forks[0]);
unlock(forks[i]);
}
else{
unlock(forks[i]);
unlock(forks[i+1]);
}
}
三、详细代码
#include "apue.h"
#include <sys/wait.h>
#include <string.h>
#include "lock.h"
#include <stdlib.h>
#define N 5
int main(int argc,char *argv[])
{
int time,i;
pid_t pid[5];
static char* forks[5] = {"fork0","fork1","fork2", "fork3", "fork4"}; if(argc==2)
time=atoi(argv[1]);
else
err_sys("error!");
for(i=0;i<N;i++)
unlock(forks[i]);
for(i = 0; i < N; i++)
{
pid[i] = fork();
if( pid[i] == 0 )
{
while(1)
{
printf("The %d philosopher is thinking\n",i);
sleep(time);
if( i == N - 1 )
{
lock( forks[0] );
lock( forks[i] );
}
else
{
lock( forks[i] );
lock( forks[i + 1] );
}
printf("The %d philosopher is eating\n",i);
sleep(time);
if( i == N - 1 )
{
unlock( forks[0] );
unlock( forks[i] );
}
else
{
unlock( forks[i] );
unlock( forks[i + 1] );
}
}
}
// if(waitpid(pid[i],NULL,0)!=pid[i])
// err_sys("waitpid error");
}
wait(NULL);
exit(0);
}
四、实验结果
四、心得体会:
这次实验总体来说偏难,整个过程不太顺利。
前期因为对多进程理解的不够透彻,导致出现各种错误。
后来详细地阅读了进程的相关章节后,才有一个较为清晰的思路。
另外在编写过程中还是会犯一些低级错误。
虽然大多是粗心所致,不过也说明自己编程不够熟练。
经过这次实验,对多进程之间的同步和互斥机制有了较好的认识,同时也意识到自身编程能力的不足。
需要在以后多多练习。