哲学家吃饭问题实验报告 操作系统

操作系统实验报告实验者：朱毅学号：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，分配给这些饥饿的哲学家筷子，若左边有筷子，取之，并标识“拥有左筷子”；若右边有筷子，取之，并标识“拥有右筷子”。

操作系统实习报告一、设计目的：死锁是进程并发执行过程中可能出现的现象，所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局。

哲学家就餐问题是描述死锁的经典例子。

为了防止死锁，可以采用资源预分配法或者资源按序分配法。

资源预分配法是指进程在运行前一次性地向系统申请它所需要的全部资源，如果系统当前不能够满足进程的全部资源请求，则不分配资源, 此进程暂不投入运行，如果系统当前能够满足进程的全部资源请求, 则一次性地将所申请的资源全部分配给申请进程。

二、设计内容哲学家进餐问题的模拟。

三、开发环境windows环境，Myeclipse平台。

四、分析设计＜一＞实验原理哲学家进餐问题描述的是五个哲学家共用一张圆桌，分别坐在周围的五张椅子上，在圆桌上有五只碗和五只筷子。

他们的生活方式是交替地进行思考和进餐。

平时，一个哲学家进行思考，饥饿时便试图取用其左右的最靠近他的筷子，只有在他拿到两只筷子时才能进餐。

进餐完毕放下筷子继续思考。

由于：①只有拿到两只筷子时，哲学家才能吃饭；②如果筷子已经在他人手上，则该哲学家必须等到他人吃完之后才能拿到筷子；③任何一个哲学家在自己没有拿到两只筷子吃饭之前，决不放下自己手中的筷子。

则可能出现五个哲学家都饥饿时都拿着一直筷子。

这样就可能五个哲学家都用不上餐。

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

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

进餐完，又先放下他左边的筷子，再放下右边筷子。

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

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

实验报告三实验名称:一、调试验证“有限缓冲”经典同步问题二、利用Java同步解决“哲学家进餐”问题日期：2015-11-5 班级：13级计科学号:姓名：一、实验目的1.了解信号量的使用2.掌握正确使用同步机制的方法3.实现生产者消费者进程的互斥与同步4.实现java同步解决“哲学家进餐”问题二、实验内容1.调试验证“有限缓冲”经典同步问题2.利用Java同步解决“哲学家进餐”问题三、项目要求与分析1.“有限缓冲”经典同步问题（1）问题描述有一群生产者进程在生产产品，此产品提供给消费者去消费。

为使生产者和消费者进程能并发执行，在它们之间设置一个具有n个缓冲池，生产者进程可将它所生产的产品放入一个缓冲池中，消费者进程可从一个缓冲区取得一个产品消费。

（2）问题分析设两个同步信号量:一个说明空缓冲区的数目，用empty表示，初值为有界缓冲区的大小N，另一个说明已用缓冲区的数目，用full表示，初值为0。

由于在执行生产活动和消费活动中要对有界缓冲区进行操作。

有界缓冲区是一个临界资源，必须互斥使用，所以另外还需要设置一个互斥信号量mutex，其初值为1。

2.“哲学家进餐”问题（1）问题描述假如所有的哲学家都同时拿起左侧筷子，看到右侧筷子不可用，又都放下左侧筷子，等一会儿，又同时拿起左侧筷子，如此这般，永远重复。

对于这种情况，即所有的程序都在无限制地运行，但是都无法得到任何进展，即出现饿死，所有的哲学家都吃不上饭。

规定在拿起左侧的筷子后，先检查右面的筷子是否可用。

如果不可用，则放下左侧的筷子，等一段时间后再重复整个过程。

（2）问题分析当出现以下情形，在某一瞬间，所有的哲学家都同时启用这个算法，拿起左侧的筷子，而看到右侧筷子都不可用，又都放下左侧筷子，等一会儿，又同时拿起左侧筷子……如此永远重复下去。

对于这种情况，所有的程序都在运行，但却都无法取得进展，即出现饿死，所有的哲学家都吃不上饭。

解决死锁问题：为了避免死锁，把哲学家分为三种状态：思考，饥饿（等待），进食，并且一次拿起两只筷子，否则不拿。

哲学家进餐问题(操作系统)哲学家进餐问题（操作系统）1. 引言文档概述：在操作系统领域，哲学家进餐问题是一个经典的并发控制问题。

该问题模拟了五位哲学家围坐在一张圆桌旁，每个哲学家面前放置着一碗面和一只叉子。

哲学家在思考和进餐之间切换，但是他们必须分享叉子来进行进餐。

然而，如果每个哲学家都同时拿起右边的叉子，就会出现死锁的情况。

因此，设计一个合理的算法来解决这个问题是非常重要的。

2. 问题描述2.1 哲学家和叉子在该问题中，有五位哲学家分别编号为 P1、P2、P3、P4、P5，以及五只叉子，编号为 F1、F2、F3、F4、F5.每个哲学家在思考时不会使用叉子，而在进餐时需要使用相邻两只叉子。

2.2 运行过程哲学家的运行过程根据以下步骤进行：- 当一个哲学家饿了后，他会尝试获取左边和右边的叉子。

- 如果两只叉子都可用，哲学家就会进餐，并在完成后释放叉子。

- 否则，哲学家需要等待其他哲学家释放叉子。

3. 解决方案为了解决哲学家进餐问题，我们可以采用以下方法之一：3.1 资源分级分配算法该算法将叉子分为左叉子和右叉子，每个哲学家只能同时拿起左叉子和右叉子。

通过约定哲学家只能按照一定顺序拿起叉子，可以避免死锁的发生。

3.2 资源分级分配算法的伪代码：```acquire_forks(left_fork_id, right_fork_id) {if (left_fork_id < right_fork_id) {acquire(left_fork_id);acquire(right_fork_id);} else {acquire(right_fork_id);acquire(left_fork_id);}}release_forks(left_fork_id, right_fork_id) { release(left_fork_id);release(right_fork_id);}philosopher(id) {while (true) {think();acquire_forks(id, (id + 1) % 5);eat();release_forks(id, (id + 1) % 5);}}```4. 附件本文档不涉及附件。

衡阳师范学院操作系统课程设计报告题目哲学家就餐问题学生姓名文润学号 ******** 专业班级计算机科学与技术1402班指导教师王玉奇完成时间 2016.11.29目录一、设计要求 (2)实验目的： (2)设计要求： (2)二、运行环境 (2)三、设计思想及流程 (2)设计思想： (2)流程图： (4)主要数据结构： (5)四、运行结果 (5)五、设计心得 (6)六、参考资料 (6)七、程序清单 (7)一、设计要求1.实验目的：通过实现哲学家就餐问题的互步，深入了解和掌握进程互斥的原理。

2.设计要求：哲学家有N个，规定全体到齐后开始讨论，在讨论的间隙哲学家就餐，每人进餐时都需使用刀、叉合一把，所有哲学家刀和叉都拿到后猜能进餐。

哲学家的人数、餐桌上的布置自行设定，实现刀和叉的互斥使用算法的程序实现。

二、运行环境操作系统:Windows系统编程语言：Java语言编译软件：Eclipse三、设计思想及流程1.设计思想：对问题分析可知，目前问题的瓶颈在于：死锁。

死锁的发生必须满足以下四个必要条件：①互斥：至少有一个资源每次只能被一个进程使用，即非共享模式。

这里指每只刀叉只能被一个哲学家持有。

②占有并等待。

一个进程因请求资源而阻塞时，对已获得的资源保持不放。

③不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。

这里指哲学家不能去抢别人的刀叉。

④循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。

在系统设计、进程调度等方面注意避免让这四个必要条件成立，如何确定资源的合理分配算法，避免进程永久占据系统资源。

此外，也要防止进程在处于等待状态的情况下占用资源。

经分析可知，放在桌子上的刀叉是临界资源，在一段时间内只允许一位哲学家使用，为了实现对刀叉的互斥使用，可以用一个信号量表示一只刀叉，由这N 个信号量组成信号量数组。

目录第一章总体设计 (3)1.程序结构设计第一章总体设计 (3)2. 程序设计组成框图………………………………………………………….错误！未定义书签。

3. 流程图……………………………………………………………………………错误！未定义书签。

第二章详细设计………………………………………………………………………………….错误！未定义书签。

1.功能说明 (5)2. 函数功能 (6)3.入口及出口参数说明 (6)4.函数调用关系描述 (7)第三章调试与测试 (8)第四章关键原程序清单和执行结果……………………………错误！未定义书签。

1.源程序…………………………………………………………………………….错误！未定义书签。

2.运行结果 (9)第五章参考资料 (9)第一章总体设计1. 程序结构设计程序需要六个线程，主线程用于显示主菜单，接收用户的功能选择；五个哲学家线程用于模拟哲学家的活动，即不停地思考、饥饿、进食。

相邻的两个哲学家线程需要共享他们中间的同一根筷子，因此对每一根筷子的使用要互斥，用互斥体数组h_mutex_chopsticks来实现。

主线程创建五个哲学家线程后要等待所有哲学家结束，用线程句柄数组h_thread来表示五个线程，主线程通过等待这五个线程句柄来实现同步。

该程序共有7个函数，这些函数可以分成4组。

各组包含的函数及其功能如图3-1所示。

2.程序设计组成框图3．流程图第二章详细设计1.功能说明系统通过简单的控制台界面，运行后在屏幕上显示功能菜单，列出该程序具有的功能，供用户选择，用户选择功能后应该转到相应的处理程序。

程序应该包括以下功能：（1）演示死锁现象；（2）通过资源按序分配法防止死锁；（3）通过资源预分配法防止死锁；（4）退出。

1.功能说明（1）演示死锁现象：演示死锁情况的哲学家线程函数，每个哲学家都得到了左边的筷子，又都在等待右边的筷子（2）通过资源按序分配法防止死锁：每个哲学家先申请左右两根筷子中编号小的筷子，再申请编号大的筷子。

操作系统实验报告哲学家就餐一、实验目的：通过模拟哲学家就餐问题，了解并掌握操作系统中的进程同步机制，以及解决进程间资源竞争所引发的死锁问题。

二、实验介绍：哲学家就餐问题是由荷兰计算机科学家伊克斯特拉(Dijkstra)于1965年首次提出的。

其问题描述如下：五位哲学家坐在一张圆桌子周围，每个哲学家面前有一碗饭和一根筷子。

哲学家的生活方式是交替地进行思考和进食。

当一个哲学家思考时，他不需要使用他的两个筷子；当一个哲学家想吃饭时，他需要同时获取他的左右两个筷子，并在获取到筷子后才能开始进食。

问题的关键是如何解决哲学家间的筷子竞争问题，以及避免死锁的发生。

三、实验设计：1.并发思路每个哲学家作为一个进程，在进行思考和进食这两个操作之前，需要获取他的两个筷子。

接下来考虑进程同步的两个关键点：-互斥：保证每个筷子同时只能被一个哲学家使用，避免资源竞争问题。

-死锁避免：通过限制只允许至多四位哲学家同时持有筷子，从而避免死锁发生。

2.进程同步机制- 互斥：使用Semaphore实现互斥，每个筷子都是一个Semaphore，初始值为1-死锁避免：引入一个全局计数器，记录当前持有筷子的哲学家数量，每次哲学家想要获取筷子时，先检查该计数器，仅当计数器小于4时才会获取筷子。

四、实验步骤：1.创建5个哲学家进程和5个筷子线程。

2.每个哲学家的线程循环执行思考和进食操作。

3.在进食之前，哲学家需要获取两个筷子，获取筷子的顺序按照哲学家编号进行，每个哲学家先获取自己的左边筷子，再获取自己的右边筷子。

4.进行进食操作后，哲学家释放两个筷子。

5.循环执行步骤3和步骤4，直到实验结束。

五、实验结果：通过观察实验结果，可以看到哲学家的思考和进食操作交替进行，并且避免了死锁的发生。

六、实验总结：通过本次实验，我了解了操作系统中的进程同步机制，并学会了如何解决资源竞争和死锁问题。

在本实验中，我使用了Semaphore和全局计数器实现了互斥和死锁避免，从而成功模拟了哲学家就餐问题。

#include <windows.h>#include <time.h>#include <string>#include <iostream>#include <assert.h>using namespace std;bool tools[5]; //全局变量，用餐工具CRITICAL_SECTION cs; //信号量, 在线程中使用，临界区class Philosopher{private:int number;int status; /*标记当前哲学家的状态,0表示正在等待(即处于饥饿状态),1表示得到两支筷子正在吃饭,2表示正在思考*/ public:Philosopher(int num=0): status(2), number(num) { }const int find(){return number;}const int getinfo(){ return status; }void Change() ; //状态改变函数void dead_lock();};/////////void Philosopher::dead_lock(){EnterCriticalSection (&cs) ; //进入临界区string s;if(status==1){tools[number%5]=true;// tools[(number-1)%5]=true;status=2;}else if(status==2){status=0;//tools[(number-1)%5]=false;//tools[(number-1)%5]=true;}else if(status==0){tools[number%5]=false;tools[(number-1)%5]=false;status=1;}LeaveCriticalSection (&cs) ;// cout<<"*********";}/////////void Philosopher::Change(){EnterCriticalSection (&cs) ; //进入临界区if(status==1) //正在进餐{tools[number%5]=true; //放下左手工具tools[(number-1)%5]=true; //放下右手工具 status=2; //改变状态为思考}else if(status==2) //思考中{status=0; //改变状态为等待}else if(status==0) //等待中{if(tools[number%5]&&tools[(number-1)%5]) //左右手两边工具均为空闲状态{tools[number%5]=false; //拿起左手工具tools[(number-1)%5]=false; //拿起右手工具status=1;}}LeaveCriticalSection (&cs) ;}string print(Philosopher *pA){//pA->Change();int i=pA->getinfo();string str;if(i==0)str="等待";else if(i==1)str="就餐";else str="思考";return str;}string toolstatus(bool a){string state;if(a==true)state="闲";if(a==false)state="用";return state;}int main(){char con='y'; //判断是否继续// con = 'n';for(int i=0;i<5;i++)tools[i]=true; //筷子都未使用，初始化Philosopher P1(1),P2(2),P3(3),P4(4),P5(5);InitializeCriticalSection (&cs) ; //初始化初始化临界区cout<<"-----------------------状态说明示意图：-----------------------"<<endl;cout<<" "<<"哲学家1号的状态"<<" "<<endl;cout<<" 筷子0的状态"<<" "<<"筷子1的状态"<<endl;cout<<"哲学家5号的状态"<<" "<<"哲学家2号的状态"<<endl;cout<<" 筷子4的状态"<<" "<<"筷子2的状态"<<endl;cout<<" 哲学家4号的状态"<<" "<<"哲学家3号的状态"<<endl;cout<<" "<<"筷子3的状态"<<endl;//cout<<" "<<"哲学家3号的状态"<<" "<<endl;cout<<"筷子的状态，用表示使用中，闲表示空闲中。

《操作系统》实验报告实验序号：03实验项目名称：哲学家问题学号姓名专业、班信管1303实验地点文波楼217实验室指导教师时间2014年11月29日一、实验目的及要求一个房间里有5个哲学家，他们的生活是思考和吃饭，房间里有一张圆桌，中间放着一碗饭菜(假设饭菜无限多)，桌子周围放有5把椅子，分别属于5位哲学家，每两位哲学家之间有一把勺子，哲学家进食时必须同时使用左右两把勺子，请为每位哲学家设计一个程序，解决他们的吃饭问题。

二、实验设备（环境）及要求硬件：一台计算机软件：装有Linux操作系统，终端窗口，文本编辑器。

三、实验内容与步骤实验代码：#include<stdio.h>#include<stdlib.h>#include<time.h>#include<semaphore.h>#include<sys/mman.h>#define F1 PROT_READ|PROT_WRITE#define F2 MAP_SHARED|MAP_ANONYMOUS#define N 5 //人数#define L 3 //行为循环次数typedef struct{sem_t ph[N];sem_t mutex;int state[N];int t;}pair;pair * p;void think(int i){printf("%d号哲学家在思考....\n", i);srand((unsigned)time(NULL));int n=rand()%10;usleep(1000000*n);printf("%d号哲学家思考完成！\n", i);}void eat(int i){printf("%d号哲学家在吃饭\n", i);srand((unsigned)time(NULL));int n=rand()%4;usleep(4000000+n*1000000);printf("%d号哲学家吃饭结束！\n\n", i);}void test(int i){if((p->state[i]==2) && (p->state[(i+1)%N]!=3) && (p->state[(N+i-1)%N]!=3)) {p->state[i]=3;sem_post(&(p->ph[i]));}}void philosopher(int i){int l=L;while(l--){think(i);sem_wait(&(p->mutex));p->state[i]=2;test(i);sem_post(&(p->mutex));sem_wait(&(p->ph[i]));eat(i);sem_wait(&(p->mutex));p->state[i]=1;test((N+i-1)%N);test((i+1)%N);sem_post(&(p->mutex));}p->t++;//t==0时父进程也要结束exit(0);}void main(){p=(pair*)mmap(NULL, sizeof(pair), F1, F2, -1, 0);//为变量开辟共享内存int i, pid;for(i=0;i<N;i++){p->state[i]=1;sem_init(&(p->ph[i]), 1, 0);}sem_init(&(p->mutex), 1, 1);p->t=0-N;for(i=0;i<N;i++){pid=fork();if(pid==0)philosopher(i);}if(pid>0){while(1)if((p->t)<0){printf("....\n");usleep(5000000);}else{//子进程已经结束，for(i=0;i<N;i++)sem_destroy(&(p->ph[i]));sem_destroy(&(p->mutex));printf("程序结束！\n");exit(0);}}}运行时也要注意线程，要输入lpthread四、实验结果与数据处理运行界面：五、分析与讨论这个问题看起来难以实现，虽然老师上课讲过，但开始拿到也觉得没那么容易，思想解决了，代码还要一步步运行，这个程序对P,V操作的用法很深，一不小心就会弄错，但是写完了之后也发现并不是想象中的那么难。

13、分析下面用信号量解决哲学家进餐问题的同步算法是否满足同步机制的准则。

若不满足，说明为什么，并给出满足同步机制准则的同步算法。

Var chopstick : array[0,...,4] of semaphore ;Chopstick[0]:=chopstick[1]:=chopstick[2]:=chopstick[3]:=chopstick[4]:=1;Pi: repeatwait(chopstick[i]);wait(chopstick[(i+1)mod 5]);eat ;signal(chopstick[i]);signal(chopstick[(i+1)mod 5]);think;until false;答：该算法不满足同步机制的"有限等待"原则，即每个哲学家都只拿一个筷子时就会产生死锁。

下面给出三种解决办法。

1、互斥申请资源设置信号量mutex初值为4，即最多可以有4个哲学家同时申请筷子。

这样保证了4个哲学家中至少有1人可以拿到两个筷子就餐而不发生死锁。

mutex=4Pi(i=0,1,...,4);Repeatwait(mutex);wait(chopstick[i]);wait(chopstick[(i+1) mod 5]);signal(mutex);Eat ;signal(chopstick[i]);signal(chopstick[(i+1)mod 5]);think;until false ;2、改变申请资源次序规定奇数号哲学家先拿起左边的筷子，然后再去拿右边的筷子；偶数号哲学家正好相反。

也即拿到一个筷子的哲学家才有权去拿下一个筷子，而没有拿到筷子的哲学家则退出竞争。

这样就不会出现5个哲学家都只拿一个筷子的情况。

pi(i=0,1,...4)repeatif odd(i) then /*如果i 为奇数*/beginwait(chopstick[i]);wait(chopstick[(i+1)mod 5]);endelsebeginwait(chopstick[(i+1)mod 5]);wait(chopstick[i]);endeat ;signal(chopstick[i]);signal(chopstick[(i+1)mod 5]);think;until false;3、采用AND型信号量机制AND型同步机制的思想是：将进程所需要的所有资源一次性全部分配给它，但只要有一个资源不能分配给该进程，则其它所有资源也不能分配给它。

操作系统——哲学家进餐问题的解决⽅法⼀、问题描述五个哲学家共⽤⼀张圆桌，分别坐在五张椅⼦上，圆桌上有五个碗和五只筷⼦。

平时哲学家进⾏思考，当即饥饿时拿起左右两边的筷⼦，只有拿到两只筷⼦时才能进餐，进餐完毕，放下筷⼦继续思考。

⼆、问题分析这是经典的进程同步问题。

筷⼦是临界资源，每只筷⼦都⽤⼀个互斥量表⽰。

semaphore chopstick[5] = {1, 1, 1, 1, 1}错误⽰例：semaphore chopstick[5] = {1, 1, 1, 1, 1};void philosopher(int i){do{wait(chopstick[i]);wait(chopstick[(i+1)%5]);//eat//...signal(chopstick[i]);signal(chopstick[(i+1)%5]);//think//...}while(true);}这样做会带来⼀个问题，当五个哲学家同时饥饿拿起左边的筷⼦时，试图拿右边的筷⼦，就会进⼊死锁。

三、解决⽅法1.⾄多有四位哲学家同时拿起左边的筷⼦，即⾄多只有四个哲学家同时进餐，这样能保证⾄少有⼀个哲学家能够进餐。

2.仅当哲学家左右两边的筷⼦都可⽤时，才能进餐3.规定奇数号哲学家先拿左边的筷⼦，再拿右边的筷⼦；偶数号哲学家相反。

解法1⽤⼀个信号量counter表⽰哲学家同时进餐的⼈数，初始值为4semaphore chopstick[5] = {1, 1, 1, 1, 1};counter=4;void philosopher(int i){do{wait(counter);wait(chopstick[i]);wait(chopstick[(i+1)%5]);//eat//...signal(chopstick[i]);signal(chopstick[(i+1)%5]);signal(counter)//think//...}while(true);}解法2使⽤AND型信号量，当两个临界资源都满⾜后才能进餐semaphore chopstick[5] = {1, 1, 1, 1, 1};void philosopher(int i){do{Swait(chopstick[i], chopstick[(i+1)%5]);//eat//...Ssignal(chopstick[i], chopstick[(i+1)%5]);//think//...}while(true);}解法3semaphore chopstick[5] = {1, 1, 1, 1, 1};void philosopher(int i){do{if(i%2){wait(chopstick[i]);wait(chopstick[(i+1)%5]);}else{wait(chopstick[(i+1)%5]);wait(chopstick[i]);}//eat//...signal(chopstick[i]);signal(chopstick[(i+1)%5]);//think//...}while(true);}。

目录1．设计题目与要求 (2)设计目的设计要求2．总体设计思想与相关知识 (2)总体设计思想问题描述解决方案3．数据结构、流程图 (2)数据结构流程图4．源代码 (3)5．运行结果 (6)6．结果分析 (7)7．总结及心得体会 (7)1．设计题目与要求设计目的掌握进程同步问题的解决思路及方法，熟练使用Windows操作系统提供的信号量机制解决各种进程同步问题。

设计要求设有五个哲学家,共用一张放有五把椅子的餐桌,每人坐在一把椅子上,桌子上有五个碗和五只筷子,每人两边各放一只筷子。

哲学家们是交替思考和进餐,饥饿时便试图取其左右最靠近他的筷子。

条件:(1) 只有拿到两只筷子时,哲学家才能吃饭。

(2) 如果筷子已被别人拿走,则必须等别人吃完之后才能拿到筷子。

(3) 任意一个哲学家在自己未拿到两只筷子吃饭前,不会放下手中拿到的筷子。

2．总体设计思想与相关知识总体设计思想哲学家的生活就是思考和吃饭，即思考，饿了就餐，再思考，循环往复。

要求是：每一个哲学家只有在拿到位于他左右的筷子后，才能够就餐；哲学家只能先拿左边的筷子，再去拿右边的筷子，而不能同时去抓他两边的筷子，也不能从其他哲学家手中抢夺筷子；哲学家每次就餐后必须放下他手中的两把筷子后恢复思考，不能强抓住餐具不放。

设计一个程序，能够显示当前各哲学家的状态和桌上餐具的使用情况，并能无死锁的推算出下一状态各哲学家的状态和桌上餐具的使用情况。

即设计一个能安排哲学家正常生活的程序。

问题描述可能出现死锁问题，因为当五个哲学家都饥饿时，都拿着一支筷子，这样就可能五个哲学家都用不上餐。

解决方案最多允许4个哲学家同时坐在桌子周围。

给所有哲学家编号，奇数号的哲学家必须首先拿左边的筷子，偶数号的哲学家则反之。

为了避免死锁，把哲学家分为三种状态，思考，饥饿，进食，仅当一个哲学家左右两边的筷子都可用时，才允许他拿筷子，并且一次拿到两只筷子，否则不拿。

3．数据结构及流程图数据结构philosopherProc+myid:int+mystate:int+philosopherProc(LPVOIDlpParameter)+ResumeThread(hPhilosopher[i]):int+strcpy(stateStr, ""):int程序中定义一个哲学家类，包含两个私有对象和四个公有对象。

线程同步操作系统实验报告实验目的：1.理解和掌握Linux线程控制的系统调用命令。

2.理解和掌握Linux线程同步的系统调用命令。

实验内容：1．Linux线程机制pthread 相关系统调用命令：pthread_create，pthread_join，pthread_mutex_lock，pthread_mutex_unlock，enter_region，leave_region等。

2. 多线程编程使用线程同步机制实现Dinning Philosophers算法。

实验代码：#include<unistd.h>#include<assert.h>#include<stdio.h>#include<stdlib.h>#include<pthread.h>#define phi_num 5#define think_time 2#define eat_time 1#define left (phi_id+phi_num-1)%phi_num#define right (phi_id+1)%phi_numenum { think , hungry , eat } phi_state[phi_num];pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;pthread_mutex_t state[phi_num]={PTHREAD_MUTEX_INITIALIZER};void Do_think(int phi_id){printf(" philosopher %d is thinking now !\n",phi_id);sleep(think_time);}void Do_eat(int phi_id){printf("philosopher %d is eating now !\n",phi_id);sleep(eat_time);}void check_phi_state(int phi_id){if(phi_state[phi_id]==hungry&&phi_state[left]!=eat&&phi_state[right]!=e at){phi_state[phi_id]=eat;pthread_mutex_unlock(&state[phi_id]);}}void Do_take_forks(int phi_id){pthread_mutex_lock(&mutex);phi_state[phi_id]=hungry;check_phi_state(phi_id);pthread_mutex_unlock(&mutex);pthread_mutex_lock(&state[phi_id]);}void Do_put_forks(int phi_id){pthread_mutex_lock(&mutex);phi_state[phi_id]=think;check_phi_state(left);check_phi_state(right);pthread_mutex_unlock(&mutex);}void *philosopher(void *arg){int phi_id=*(int *)arg;while(1){Do_think(phi_id);Do_take_forks(phi_id);Do_eat(phi_id);Do_put_forks(phi_id);}return NULL;}int main(int argc, char *argv[]){int num;pthread_t *phi=(pthread_t*)malloc(sizeof(pthread_t)*phi_num);int *id=(int *)malloc(sizeof(int)*phi_num);for(num=0;num<phi_num;num++){id[num]=num;pthread_create(&phi[num],NULL,philosopher,(void*)(&id[num]));}for(num=0;num<phi_num;num++){pthread_join(phi[num],NULL);}return 0;}截图：。

《操作系统》实验报告实验题目：哲学家进餐问题一、实验目的：实现linux下哲学家进餐问题。

体会如何控制进程同步与互斥的信号量方法。

二、实验内容：运用linux下fork，IPC信号量机制中的相关系统调用，IPC共享存储器机制，实现哲学家进餐问题。

三、编程环境及工具Linux下GCC四、具体设计要求及有关说明Fork() 在子进程刚被创建时，它和父进程具有相同的共享正文段，而其他进程信息则完全拷贝父进程得到。

信号量调用的示例程序：#include <sys/types.h>#include <sys/ipc.h>#include <sys/sem.h>#include <stdio.h>union semun {int val;struct semid_ds *buf;ushort * array;}argument;int main(){int id; /* Number by which the semaphore is known within a program */argument.val = 0;//新建一个信号量集合，包含一个信号量id = semget(IPC_PRIV ATE, 1, 0666 | IPC_CREAT);if(id < 0){printf("Unable to obtain semaphore.\n ");exit(-1);}//将信号量的值置为0if( semctl(id, 0, SETV AL, argument) < 0){printf("Cannot set semaphore value.\n");}else{printf("Semaphore initialized.\n");}}int lock_sem(int semid, int member){/*初始化sembuf结构，将指定信号量值减1。

哲学家进餐问题(操作系统)哲学家进餐问题(操作系统)1.简介1.1 背景介绍哲学家进餐问题是计算机科学中一个经典的并发问题，最早由Edsger Dijkstra在1965年提出。

1.2 问题描述问题的场景是五位哲学家围坐在一张圆桌前，每个哲学家面前有一碗饭和一根筷子。

哲学家需要交替地思考和进餐，但是他们只能使用左右两边的筷子来进餐。

1.3 目标设计一个算法来保证哲学家们能够交替地进餐，同时避免死锁和饥饿现象的发生。

2.解决方案2.1 简单解法一个简单的解法是给每个哲学家编号，规定奇数号哲学家先拿左边的筷子，偶数号哲学家先拿右边的筷子。

当一个哲学家需要拿筷子时，他会先检查他的两边是否有其他哲学家正在使用，如果没有，他就可以拿起两边的筷子进餐。

否则，他需要等待直到两边的筷子都可用。

2.2 改进解法上述简单解法可能会导致死锁问题。

为了避免死锁，我们可以引入资源分级的概念。

每个筷子被分为两个等级，分别是主要资源和次要资源。

哲学家需要按照顺序来获取资源，例如，先获取主要资源，然后获取次要资源。

3.算法实现3.1 数据结构我们可以使用一个数组来表示圆桌上的五个筷子，同时使用一个锁数组来表示每个筷子的状态（是否被占用）。

3.2 算法流程在哲学家进餐问题中，每个哲学家都需要经历思考和进餐两个过程，我们可以使用线程来模拟这两个过程。

4.算法分析4.1 死锁问题通过引入资源分级的概念，我们成功避免了死锁问题的发生。

每个哲学家按照顺序获取资源，不会出现他们都在等待同一个资源的情况。

4.2 饥饿问题在我们的算法中，每个哲学家都会交替地进餐和思考，因此不会出现饥饿问题。

5.附件本文档暂无附件。

6.法律名词及注释6.1 死锁死锁是指在并发系统中，两个或多个进程或线程无限期地互相等待对方所占有的资源的情形。

6.2 饥饿饥饿是指某个进程或线程因无法获得所需的资源而无法继续执行的情况。

实践15 哲学家进餐问题1.实践内容说明（1）在函数中使用图形方式显示哲学家进餐问题，每个哲学家使用一个线程控制，随机进行进餐或者思考，使用互斥量和事件进行同步和互斥控制。

2.程序性质（1）Windows 和控制台混合应用程序（2）多线程3.运行环境设置（1）建立项目在Visual C++ 开发环境，单击New 菜单，弹出New 对话框；在New 对话框中选择Project 标签切换至Project 标签页；在Project 标签页的项目列表中选择Win32 Application 选项，Location 输入框输入项目所在的路径，或者单击输入框右侧的按钮，在弹出的Choose Directory 对话框中选择项目所在的磁盘分区和所在的目录；在Project 标签页的Project name 输入框中输入项目名称；Project 标签页中的其他选项保持默认选择（单选框Create new workspace 前有黑点，Platforms 选项框中Win32 前打勾），完成设置界面如图10 所示。

图10 设置项目为Windows 应用完成设置后单击OK，New 对话框关闭，弹出Win32 Console Application –Step 1 of 1 对话框。

在Win32 Console Application –Step 1 of 1 对话框中选择An empty project 单选项。

Win32 Console Application –Step 1 of 1 对话框如图11 所示。

图11 说明刚建立的项目为空项目完成Win32 Console Application –Step 1 of 1 对话框后单击Finish 按钮，Win32 Console Application –Step 1 of 1 对话框关闭，弹出New Project Information 对话框。

New Project Information 对话框中显示了当前建立项目的一些信息。

操作系统哲学家就餐问题实验报告实验目的：通过实验探究操作系统中的哲学家就餐问题，了解并掌握解决该问题的不同算法。

实验原理：哲学家就餐问题是一个典型的并发控制问题，该问题描述了一群哲学家围坐在圆桌上，每个哲学家左右两边各有一只筷子，哲学家只有同时拿到左右两只筷子时才能进餐，进餐完毕后将筷子放回桌面。

该问题的解决涉及到互斥、死锁、饥饿等并发问题。

实验步骤：1. 实现基于信号量的解法：- 为每个哲学家和筷子创建一个信号量；- 哲学家进入就餐前先检查左右两只筷子是否可用；- 若可用，则将左右两只筷子设置为不可用，并进餐；- 进餐完毕后将左右两只筷子设置为可用。

2. 实现基于管程的解法：- 哲学家类中定义进餐和放下筷子的方法；- 使用一个互斥锁来确保每次只有一个哲学家能进入管程；- 当某个哲学家想要进餐时，先检查是否有足够的筷子可用；- 若可用，则进入进餐方法，将筷子设置为不可用，并开始进餐； - 进餐完毕后，释放筷子并通知其他哲学家。

3. 运行实验程序，观察哲学家的就餐过程。

4. 分析实验结果，比较两种算法的优缺点。

实验结果与分析：通过观察实验程序运行的结果，可以发现在基于信号量的解法中，哲学家的就餐过程是以并发的方式进行的，每个哲学家在不产生死锁的前提下获取到筷子并进餐。

但是，由于每个哲学家只能同时拿到一只筷子，有可能会出现饥饿的情况，即某个哲学家一直无法获取到筷子进餐。

而基于管程的解法则能够避免饥饿的问题，每个哲学家在进餐前都会检查是否有足够的筷子可用，若不可用则等待。

通过互斥锁的使用，确保每次只有一个哲学家能够进入管程进行操作，避免了并发产生的问题。

综上所述，基于管程的解法相对于基于信号量的解法更加可靠，能够避免饥饿问题的出现。

但是在实际应用中，两种解法的选择还需要根据具体情况进行权衡和取舍。