计算机操作系统_哲学家就餐问题_C++实现源代码
利用信号量机制解决哲学家进餐的问题c语言
利用信号量机制解决哲学家进餐的问题c语言哲学家进餐问题是经典的并发编程问题，主要是模拟多个哲学家同时在桌子上进行吃饭和思考。
由于每个哲学家都需要同时拿起左右两边的餐叉才能进餐，如果不加以控制，容易导致死锁的情况发生。
为了解决这个问题，可以利用信号量机制来确保每个哲学家同时只能拿到一把餐叉，从而避免死锁的发生。
首先，我们需要定义一些全局变量和信号量来表示哲学家和餐叉的状态。
```c#include <stdio.h>#include <stdlib.h>#include <pthread.h>#include <semaphore.h>#define N 5 // 哲学家的数量pthread_t philosophers[N]; // 哲学家的线程pthread_mutex_t forks[N]; // 餐叉的互斥锁sem_t room; // 哲学家就餐的信号量void *philosopher(void *arg) {int id = *(int *)arg;int right = id;int left = (id + 1) % N;while (1) {// 思考sleep(rand() % 3 + 1);// 请求餐叉sem_wait(&room);pthread_mutex_lock(&forks[right]);pthread_mutex_lock(&forks[left]);// 进餐sleep(rand() % 3 + 1);printf("Philosopher %d is eating\n", id + 1);// 放下餐叉pthread_mutex_unlock(&forks[left]);pthread_mutex_unlock(&forks[right]);sem_post(&room);}}int main() {int i, id[N];// 初始化互斥锁和信号量sem_init(&room, 0, N - 1); // 初始信号量为N-1，表示有N-1个座位可供就餐for (i = 0; i < N; i++) {pthread_mutex_init(&forks[i], NULL);}// 创建哲学家线程for (i = 0; i < N; i++) {id[i] = i;pthread_create(&philosophers[i], NULL, philosopher, &id[i]); }// 等待哲学家线程结束for (i = 0; i < N; i++) {pthread_join(philosophers[i], NULL);}// 销毁互斥锁和信号量for (i = 0; i < N; i++) {pthread_mutex_destroy(&forks[i]);}sem_destroy(&room);return 0;}```在主函数中，我们首先定义了哲学家和餐叉的线程以及信号量。
哲学家就餐问题代码
哲学家就餐问题代码哲学家就餐问题是一个经典的并发编程问题，描述了五位哲学家围坐在圆桌旁，每个哲学家面前有一碗米饭和一只筷子。
哲学家的生活由思考和就餐两个活动组成，思考时不需要筷子，但就餐时需要同时拿起自己左右两边的筷子才能进餐。
问题在于如何设计算法，使得每位哲学家都能够顺利地进行思考和就餐，而不会发生死锁。
以下是一个简单的解决方案，使用Java语言实现：java.import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;class Philosopher implements Runnable {。
private int id;private Lock leftChopstick;private Lock rightChopstick;public Philosopher(int id, Lock leftChopstick, Lock rightChopstick) {。
this.id = id;this.leftChopstick = leftChopstick;this.rightChopstick = rightChopstick;}。
private void think() {。
System.out.println("哲学家 " + id + " 正在思考");try {。
Thread.sleep((long) (Math.random() 1000));} catch (InterruptedException e) {。
e.printStackTrace();}。
}。
private void eat() {。
leftChopstick.lock();rightChopstick.lock();System.out.println("哲学家 " + id + " 正在就餐");try {。
用C语言实现哲学家进餐的问题
用C语言实现哲学家进餐的问题设有个哲学家共享一张放油把椅子的桌子每人分得一吧椅子但是桌子上总共执友支筷子在每个人两边分开各放一支哲学家只有在肚子饥饿时才试图分两次从两边拾起筷子就餐就餐条件是:)哲学家想吃饭时先提出吃饭的要求;)提出吃饭要求并拿到支筷子后方可吃饭;)如果筷子已被他人获得则必须等待该人吃完饭之后才能获取该筷子;)任一哲学家在自己未拿到支筷子吃饭之前决不放下手中的筷子;)刚开始就餐时只允许个哲学家请求吃饭试问:)描述一个保证不会出现两个邻座同时要求吃饭的算法;)描述一个既没有两邻座同时吃饭又没有人饿死的算法;)在什么情况下个哲学家全都吃不上饭?哲学家进餐问题是典型的同步问题它是由Dijkstra提出并解决的该问题是描述有五个哲学家他们的生活方式是交替地进行思考和进餐哲学家们共用一张圆桌分别坐在周围的五张椅子上在圆桌上有五个碗和五支筷子平时一个哲学家进行思考饥饿时便试图取用其左右岁靠近他的筷子只有在他拿到两支筷子时才能进餐进餐完毕放下筷子继续思考利用记录型信号量解决哲学家进餐问题经分析可知筷子是临界资源在一段时间只允许一个哲学家使用因此可以用一个信号量表示一支筷子由这五个信号量构成信号量数组其描述如下:var chopstick:array[ ]of semaphore;所有信号量被初始化为第i个哲学家的活动可描述为:repeatwait(chopstick);wait(chopstick[(i+ ) mod ]);eat;signal(chopstick);signal(chopstick[(i+ ) mod ]);think;until false;在以上描述中哲学家饥饿时总是先去拿他左边的筷子即执行wait(chopstick);成功后再去拿他右边的筷子即执行wait(chopstick[(i+ ) mod ]); 再成功后便可进餐进餐完毕又先放下他左边的筷子然后放下他右边的筷子虽然上述解法可保证不会有两个相临的哲学家同时进餐但引起死锁是可能的假如五个哲学家同时饥饿而各自拿起右边的筷子时就会使五个信号量chopstick均为 ;当他们试图去拿右边的筷子时都将因无筷子可拿而无限期地等待对于这样的死锁问题可采用以下集中解决方法:( )至多只允许四个哲学家同时进餐以保证至少有一个哲学家能够进餐最终总会释放出他所使用过的两支筷子从而可使更多的哲学家进餐( )仅当哲学家的左右两支筷子都可用时才允许他拿起筷子进餐( )规定奇数号的哲学家先拿起他左边的筷子然后再去拿他右边的筷子;而偶数号的哲学家则相反按此规定将是号哲学家竞争号筷子号哲学家竞争号筷子即五个哲学家都竞争奇数号筷子获得后再去竞争偶数号筷子最后总会有一个哲学家能获得两支筷子而进餐看了整整一个上午的操作系统看得头都大了我们老师的算法的大意好像是用一个总的信号量只有获得信号量的哲学家才可以拿筷子具体算法如下（用类c描述）#include 所有头文件#define N#define left (i )%N //i的左邻号码#define right (i+ )%N //i的右邻号码#define think#define hungry#define eatingtypedef int semaphore //信号量是一个特殊的整型变量int state[N] //记录每个人的状态semaphore mutex= ; //设置信号量semaphore s[N]; //每个哲学家一个信号量void philosopher(int i){while(true) //无限循环{think;take_chopstick(i);eat;put_chopstick(i);}}void take_chopstick(int i){p(& mutex); //对信号量的p操作state=hungry;test(i); //试图得到两支筷子v(&mutex); //v操作p(&s); //得不到筷子则阻塞}void put_chopstick(int i){p(& mutex);state=think; //进餐结束test(left); //看左邻是否进餐test(right); //再看右邻v(&mutex);}void test(int i){if（state==hungry&&左邻没进餐&&右邻没进餐）{state=eating;v(&s);}lishixinzhi/Article/program/c/201404/30443。
操作系统课程设计利用多线程和信号量解决哲学家进餐问题java实现
操作系统课程设计课程设计报告课题：利用信号量和多线程机制实现“哲学家进餐”问题所在学院：信息工程学院班级：计科1201学号：121404114姓名：魏祥指导教师：徐向英2015年1月1日目录一、课程设计目标 (3)二、课题内容 (3)三、设计思路 (3)四、源代码 (5)五、运行与测试 (9)六、心得体会 (10)一、课程设计目标学习多线程编程，使用线程的同步机制实现“哲学家进餐”问题。
具体要求：1.创建POSIX线程，实现多线程的并发执行，验证多线程共享进程资源的特性。
2.使用互斥量和条件变量，或使用信号量实现线程的同步互斥。
3. 验证“ 哲学家进餐”问题中的死锁情况，并加以解决。
二、课题内容哲学家进餐问题由Dijkstra提出，问题描述有五个哲学家共用一张圆桌，分别坐在周围的五张椅子上，在圆桌上有五个碗和五支筷子，他们的生活方式是交替地进行思考和进餐。
平时，一个哲学家进行思考，饥饿时便试图取用其左右最靠近他的筷子，只有在他拿到两只筷子时才能进餐。
进餐完毕，放下筷子继续思考。
本次课题要求使用多线程和信号量解决哲学家进餐问题。
并演示产生死锁的情况。
三、设计思路经分析可知，放在桌子上的筷子是临界资源，在一段时间内只允许以为哲学家使用。
为了实现对筷子的互斥，可以用一个信号量表示一只筷子，由着五个信号量构成信号量数组。
当哲学家饥饿时总是先去拿左筷子，成功后在拿右筷子。
当五位哲学家同时拿起左筷子，这是每位哲学家都没有右筷子可以拿，就会造成死锁。
思路1：利用记录型信号量设置值为4的记录型信号量，至多只允许四位哲学家同时去拿左筷子(leftStick.getSema().acquire())，只有拿到左筷子，才能继续拿右筷子(rightStick.getSema().acquire())。
拿到两双筷子之后便可以用餐，用餐完毕，先放下左筷子(leftStick.getSema().release())，再放下右筷子(rightStick.getSema().release())。
哲学家就餐-操作系统
衡阳师范学院操作系统课程设计报告题目哲学家就餐问题学生姓名文润学号 ******** 专业班级计算机科学与技术1402班指导教师王玉奇完成时间 2016.11.29目录一、设计要求 (2)实验目的： (2)设计要求： (2)二、运行环境 (2)三、设计思想及流程 (2)设计思想： (2)流程图： (4)主要数据结构： (5)四、运行结果 (5)五、设计心得 (6)六、参考资料 (6)七、程序清单 (7)一、设计要求1.实验目的：通过实现哲学家就餐问题的互步，深入了解和掌握进程互斥的原理。
2.设计要求：哲学家有N个，规定全体到齐后开始讨论，在讨论的间隙哲学家就餐，每人进餐时都需使用刀、叉合一把，所有哲学家刀和叉都拿到后猜能进餐。
哲学家的人数、餐桌上的布置自行设定，实现刀和叉的互斥使用算法的程序实现。
二、运行环境操作系统:Windows系统编程语言：Java语言编译软件：Eclipse三、设计思想及流程1.设计思想：对问题分析可知，目前问题的瓶颈在于：死锁。
死锁的发生必须满足以下四个必要条件：①互斥：至少有一个资源每次只能被一个进程使用，即非共享模式。
这里指每只刀叉只能被一个哲学家持有。
②占有并等待。
一个进程因请求资源而阻塞时，对已获得的资源保持不放。
③不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
这里指哲学家不能去抢别人的刀叉。
④循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。
在系统设计、进程调度等方面注意避免让这四个必要条件成立，如何确定资源的合理分配算法，避免进程永久占据系统资源。
此外，也要防止进程在处于等待状态的情况下占用资源。
经分析可知，放在桌子上的刀叉是临界资源，在一段时间内只允许一位哲学家使用，为了实现对刀叉的互斥使用，可以用一个信号量表示一只刀叉，由这N 个信号量组成信号量数组。
操作系统哲学家就餐问题课程设计c语言
1.1 设计题目描述：
用多线程同步方法解决哲学家就餐问题(Dining-Philosophers Problem)
1.2 要求：
1）为每个哲学家产生一个线程，设计正确的同步算法 2）每个哲学家取得一双筷子开始用餐后，即时显示“Dining…”和该哲学 家的自定义标识符以及餐桌上所有几位哲学家标识符及其所坐的位置。 3）设定共有 5 个哲学家需用餐。每位用餐耗时 10 秒钟以上。 4）多个哲学家须共享操作函数代码。
针对每个哲学家通过共享操作函数代码分别建立5个线程以实现同步哲学家就餐而申请进入餐厅的哲学家进入room的等待队列根据fifo的原则总会进入到餐厅就餐因此不会出现饿死和死锁的现象针对5只筷子分别设置了5个互斥信号量以保证每只筷子每次只能被取得一次
武汉理工大学《操作系统》课程设计
题 目 : 用 多 线 程 同 步 方 法 解 决 哲 学 家 就 餐 问 题 (Dining-Philosophers
2． 设计说明书内容要求： Nhomakorabea1)设计题目与要求 2)总的设计思想及系统平台、语言、工具等。 3）数据结构与模块说明（功能与流程图） 4） 给出用户名、 源程序名、 目标程序名和源程序及其运行结果。 （要 注明存储各个程序及其运行结果的 Linux 主机 IP 地址和目录。 ） 5）运行结果与运行情况 （提示: (1)连续存储区可用数组实现。 (2)编译命令可用： cc (3)多线程编程方法参见附件。 ）
2.2 系统平台、语言及工具
（1）操作系统：Linux （2）程序设计语言：C 语言 （3）工具：编辑工具 Vi、编译器 gcc
1
武汉理工大学《操作系统》课程设计
3．数据结构与模块说明
线程创建函数 pthread_create 声明如下： #include <pthread.h> int pthread_create (pthread_t *thread,pthread_attr_t *attr,Void* (*start_routine)(void *),void *arg);
计算机操作系统_哲学家就餐问题_C++实现源代码
计算机操作系统_哲学家就餐问题_C++实现源代码//哲学家就餐问题的解法#include <windows.h>#include <process.h>#include <time.h>#include <stdlib.h>#include <stdio.h>#include <iostream>using namespace std; //命名空间std内定义的所有标识符都有效const unsigned int PHILOSOPHER_NUM=5; //哲学家数目const char THINKING=1; /*标记当前哲学家的状态,1表示等待,2表示得到饥饿,3表示正在吃饭*/const char HUNGRY=2;const char DINING=3;HANDLE hPhilosopher[5]; //定义数组存放哲学家/*HANDLE(句柄)是windows操作系统中的一个概念。
指的是一个核心对象在某一个进程中的唯一索引*/HANDLE semaphore[PHILOSOPHER_NUM]; // semaphore 用来表示筷子是否可用HANDLE mutex; // Mutex用来控制安全输出DWORD WINAPI philosopherProc( LPVOID lpParameter) //返回 DWORD（32位数据）的 API 函数philosopherProc{int myid;char idStr[128];char stateStr[128];char mystate;int ret;unsigned int leftFork; //左筷子unsigned int rightFork; //右筷子myid = int(lpParameter);itoa(myid, idStr, 10);WaitForSingleObject(mutex, INFINITE);cout << "philosopher " << myid << " begin......" << endl; ReleaseMutex(mutex);mystate = THINKING; //初始状态为THINKINGleftFork = (myid) % PHILOSOPHER_NUM;rightFork = (myid + 1) % PHILOSOPHER_NUM;while (true){switch(mystate){case THINKING:mystate = HUNGRY; // 改变状态strcpy(stateStr, "HUNGRY");break;case HUNGRY:strcpy(stateStr, "HUNGRY");ret = WaitForSingleObject(semaphore[leftFork], 0); // 先检查左筷子是否可用if (ret == WAIT_OBJECT_0){ret = WaitForSingleObject(semaphore[rightFork], 0); //左筷子可用就拿起，再检查右筷子是否可用if (ret == WAIT_OBJECT_0){mystate = DINING; // 右筷子可用，就改变自己的状态strcpy(stateStr, "DINING");}else{ReleaseSemaphore(semaphore[leftFork], 1, NULL); // 如果右筷子不可用，就把左筷子放下}}break;case DINING:// 吃完后把两支筷子都放下ReleaseSemaphore(semaphore[leftFork], 1, NULL);ReleaseSemaphore(semaphore[rightFork], 1, NULL);mystate = THINKING; // 改变自己的状态strcpy(stateStr, "THINKING");break;}// 输出状态WaitForSingleObject(mutex, INFINITE);cout << "philosopher " << myid << " is : " << stateStr << endl;ReleaseMutex(mutex);// sleep a random time : between 1 - 5 sint sleepTime;sleepTime = 1 + (int)(5.0*rand()/(RAND_MAX+1.0));Sleep(sleepTime*10);}}int main(){int i;srand(time(0));mutex = CreateMutex(NULL, false, NULL);for (i=0; i<PHILOSOPHER_NUM; i++){semaphore[i] = CreateSemaphore(NULL, 1, 1, NULL);hPhilosopher[i]=CreateThread(NULL,0,philosopherProc,LPVOID(i), CREATE_SUSPENDED,0);}for (i=0; i<PHILOSOPHER_NUM; i++)ResumeThread(hPhilosopher[i]);Sleep(2000);return 0;}。
哲学家就餐问题--C原代码
哲学家就餐问题--C原代码/*题目：一群哲学家围坐在一个圆桌，手上持有密码m，并从1开始编了号取初值m，哲学家从1开始报数, 报到m的哲学家停止吃饭，退出圆桌，求哲学家退出的顺序。
要求:n和初值m由完家输入.手上的密码随机产生.最后要打印出编号对应的密码，输出哲学家离开的相后顺序分析:可用循环链表实现，链表数据类型为结构体，记录编号和相应密码，另外设标志哲学家报数的变量mouth, 它的值和哲学家嘴上报的数相等,则如果mouth和m相等,该哲学家就应该离开离开前取他的密码交给m,同时将他的编号放另一单链表numbsave保存。
注意编号要从numbsave的最后节点插入。
当循环链表指向自身时停止比较,这个哲学家即是最后离开的一个.依次打印出numbsave中的数即为按编号哲学家离开的先后顺序。
*/#include "stdio.h"#include "conio.h"#include "stdlib.h"struct philosopher /*哲学家就餐结构体*/{ int number; /*编号*/int password;int mouth; /*嘴上报的数*/struct philosopher *next;};struct philosopher *phead,*pend,*pp;struct numbsave /*存放离开顺序*/{ int numsave;struct numbsave *next;};struct numbsave *top=NULL,*numbnew,*numbthis;void main(void){ char *p,d;int b=1,k,n,m,mouthm=1;clrscr(); gotoxy(9,8);printf("please input n m:");scanf("%d%d",&n,&m); /*n为哲学家人数，m为初始密码*/phead=(struct philosopher *)malloc(sizeof(struct philosopher));pend=phead;phead->mouth=1;for(b=1;b<=n-1;b++) /*给哲学家分配随机密码*/{pend->number=b;k=random(20); /*k为0<kwhile(k<=0)k=random(20);pend->password=k;pp=(struct philosopher *)malloc(sizeof(struct philosopher));pend->next=pp; pend=pp;}pend->number=b; /*最后一位哲学家*/k=random(20); while(k<=0) k=random(20); pend->password=k; pend->next=phead; /*形成循环链表*/printf("\n\tphilosopher number correspondence password as followed:\n\t");pp=phead;for(b=1;b<=n;b++){printf("%d:%d\t",pp->number,pp->password);pp=pp->next;}while(pend->next!=pend){if(phead->mouth==m) /*如果嘴上报数和m相等，意味着一个人要走了*/{pp=phead;phead->next->mouth=1; mouthm=1; /*下一位哲学家从一开始报,mm用于将顺序报出数的交给嘴巴*/phead=pend->next=phead->next; /*两个指针一定要相邻*/numbnew=(struct numbsave*)malloc(sizeof(struct numbsave));m=pp->password; /*修改m的值为离开哲学家的password*/numbnew->numsave=pp->number;if(top==NULL) {top=numbnew; top->next=NULL;} /*离开的哲学家的编号存入numbsave 的最后节点*/else { numbthis=top;while(numbthis->next!=NULL) numbthis=numbthis->next;numbthis->next=numbnew; numbnew->next=NULL;}free(pp);}else {pend=pend->next;phead=phead->next; /*让phead指向下一个*/mouthm++;phead->mouth=mouthm; /*嘴巴说我该报mouthm*/}} /*打印离桌顺序*/printf("\n\tphilosopher away from cookdesk in the follow queue:\n\t");while(top!=NULL){ printf("%d ",top->numsave);top=top->next;}printf("%d ",pend->number); /*这个千万别忘了，他是运气的一位*/printf("\n\tpress any key to go back......");while(!kbhit()) ;}。
操作系统哲学家进餐实验
《操作系统》实验报告实验题目：哲学家进餐问题一、实验目的：实现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。
【精选资料】哲学家就餐问题代码
【精选资料】哲学家就餐问题代码#include#include#include#include#include#include#include#include#include#define NUM_THREADS_P 5 /*define the number of philosopher*/#define CHAIR_NUM 4#define CHOP_NUM 5int chairflg[CHAIR_NUM][2],dining_num=0;sem_tchair,chopsticks[CHOP_NUM],mutex,mutex1,print_mutex;// 设定信号量pthread_t threads_p[NUM_THREADS_P]; /*philosopher*/ void* philosopher_thread(int tid);int main(){int i;sem_init(&chair,0,CHAIR_NUM); /*set the value of semaphores*/for(i=0;i<chop_num;i++)< bdsfid="90" p=""></chop_num;i++)<>{sem_init(&chopsticks[i],0,1);}sem_init(&mutex,0,1);sem_init(&mutex1,0,1);sem_init(&print_mutex,0,1);for(i=0;i<4;i++)chairflg[i][0]=0;/*create the threads*/for(i=0;i<num_threads_p;i++)< bdsfid="100" p=""></num_threads_p;i++)<>pthread_create(&threads_p[i],NULL,(void*)philosopher_thre ad,(void*)(i));/*wait the threads to exit*/for(i=0;i<num_threads_p;i++)< bdsfid="104" p=""></num_threads_p;i++)<>pthread_join(threads_p[i],NULL);/*destroy the semaphores*/sem_destroy(&chair);sem_destroy(&chopsticks[CHOP_NUM]);sem_destroy(&mutex);sem_destroy(&mutex1);sem_destroy(&print_mutex);return 0;}void* philosopher_thread(int tid){int i;i=tid;sem_wait(&chair);sem_wait(&mutex);for(i=0;i<chair_num;i++){< bdsfid="121" p=""></chair_num;i++){<>if(chairflg[i][0]==0){ /*the chair is empty*/chairflg[i][0]=1;chairflg[i][1]=(int)i;/*philosopher(i) toke the chair*/break;}}dining_num++;sem_post(&mutex);sem_wait(&chopsticks[i]);printf("philosopher %d get chopstics %d\n",i,i);sem_wait(&chopsticks[(i+1)%CHOP_NUM]);printf("philosopher %d get chopstics %d\n",tid,(i+1)%CHOP_NUM);sleep(rand()%3);sem_wait(&print_mutex);printf("philosopher %d is dining.when he is dining ,there are %d philosophers at table.\n",(int)i,dining_num);for(i=0;i<chair_num;i++){< bdsfid="138" p=""></chair_num;i++){<>if(chairflg[i][0]==1){printf("poilosopher %d in chair %d. ",chairflg[i][1],i+1);}}printf("\n\n");sem_post(&print_mutex);sleep(rand()%3);sem_post(&chopsticks[i]);sem_post(&chopsticks[(i+1)%CHOP_NUM]);sem_wait(&mutex1);for(i=0;i<chair_num;i++){< bdsfid="150" p=""></chair_num;i++){<>if(chairflg[i][1]==(int)i){chairflg[i][0]=0;break;}}dining_num--;sem_post(&mutex1);sem_post(&chair);printf("philosopher %d leaves\n",(int)i);return ((void*)0);}$$$$$$$$$$$$$$$$$$$$$$$$$#include#include#include#include#include#define PHILOSOPHER_NUM 5#define THINKING 0#define HUNGRY 1#define EATING 2pthread_mutex_t mutex;sem_t semph[PHILOSOPHER_NUM];#define LEFT (i + PHILOSOPHER_NUM -1)%PHILOSOPHER_NUM //i 的左领居编号#define RIGHT (i + 1)%PHILOSOPHER_NUM //i 的右领居编号int state[PHILOSOPHER_NUM];void think(int i){}void eat(int i){}void test(int i){if((state[i] == HUNGRY )&& (state[LEFT] != EATING)&& (state[RIGHT]!= EATING)) {state[i] = EA TING;sem_post(&semph[i]);}}void take_forks(int i){pthread_mutex_lock(&mutex); state[i] = HUNGRY;test(i);pthread_mutex_unlock(&mutex); sem_wait(&semph[i]);}void put_forks(int i){pthread_mutex_lock(&mutex); state[i] = THINKING;test(LEFT);test(RIGHT);pthread_mutex_unlock(&mutex); }void philosopher(int *index) {int mythreadId = (*index);int sleepTime;bzero(state,0);while(1){think(mythreadId);take_forks(mythreadId);eat(mythreadId);put_forks(mythreadId);// sleep a random time : between 1 - 5 ssleepTime = 1 + (int)(5.0*rand()/(RAND_MAX+1.0));usleep(sleepTime*10);}}int main(){int i,ret;int threadId[PHILOSOPHER_NUM];int errNum=0;pthread_t t_phThread[PHILOSOPHER_NUM];pthread_t t_threadInfo;srand(getpid());pthread_mutex_init(&mutex,NULL);//ret = pthread_create(&t_threadInfo, NULL, (void *) threadInfo, (void *) NULL);if( ret ){errNum++;}for(i=0;i<philosopher_num;i++)< bdsfid="244"p=""></philosopher_num;i++)<>{threadId[i] = i;sem_init(&semph[i],0,1);ret=pthread_create(&t_phThread[i], NULL, (void *)philosopher, (void*)(&threadId[i]));if(ret){errNum++;}usleep(20);}if(errNum){printf("thread create err! errnum=%d \n",errNum);}sleep(1);}#include#include#include#include#include#define PHILOSOPHER_NUM 5#define THINKING 1#define HUNGRY 2#define EATING 3pthread_mutex_t mutex;sem_t semph[PHILOSOPHER_NUM];void philosopher(int *index){int mythreadId;char myState,strState[128];int leftIndex;int rightIndex;int sleepTime;mythreadId = (*index);leftIndex = mythreadId + PHILOSOPHER_NUM-1）% PHILOSOPHER_NUM;rightIndex = (mythreadId + 1) % PHILOSOPHER_NUM;myState = THINKING;while(1){switch(myState){case THINKING:myState = HUNGRY;strcpy(strState,"HUNGRY");break;case HUNGRY:strcpy(strState,"HUNGRY");if(!(sem_wait(&semph[leftIndex]))){if(!(sem_wait(&semph[rightIndex]))){myState = EATING;strcpy(strState,"EATING");}else{//不能同时拿起则都不拿起sem_post(&semph[leftIndex]);}}break;case EATING:sem_post(&semph[leftIndex]);sem_post(&semph[rightIndex]);myState=THINKING;strcpy(strState,"THINKING");break;}pthread_mutex_lock(&mutex);printf("pholosopher %d begin %s\n",mythreadId,strState);pthread_mutex_unlock(&mutex);sleepTime = 1+(int)(5.0*rand()/(RAND_MAX+1.0));usleep(sleepTime);}}int main(){int i,ret;int threadId[PHILOSOPHER_NUM];int errNum=0;pthread_t t_phThread[PHILOSOPHER_NUM];//pthread_t t_threadInfo;srand(getpid());pthread_mutex_init(&mutex,NULL);for(i=0;i<philosopher_num;i++)< bdsfid="335" p=""></philosopher_num;i++)<>{threadId[i] = i;sem_init(&semph[i],0,1);ret=pthread_create(&t_phThread[i], NULL, (void *)philosopher, (void*)(&threadId[i]));if(ret){errNum++;}usleep(20);}if(errNum){printf("thread create err! errnum=%d \n",errNum);}sleep(1);}%%%%%%%%%%%%%%%%%%%1.#include2.#include3.#include4.#include5.#include6.#include7.8.#define PEOPLE_NUM 59.#define THINKING 110.#define HUNGRY 211.#define EATING 312.13.sem_t chopsticks[PEOPLE_NUM];14.pthread_mutex_t mutex;15.16.void *philosopher(void *arg){17.int id = (int) arg;18.19.int state = THINKING;20.int right = (id + 1) % PEOPLE_NUM;21.int left = (id + PEOPLE_NUM - 1) % PEOPLE_NUM;22.char ptrState[32];23.24.while(1){25.switch(state){26.case THINKING:27. usleep(300);28. state = HUNGRY;29. strcpy(ptrState,"Thinking before eat");30.break;31.case HUNGRY:32. strcpy(ptrState,"Hungry");33.if(sem_wait(&chopsticks[left]) == 0){//阻塞状态34.if(sem_trywait(&chopsticks[right]) == 0){//非阻塞35. strcpy(ptrState,"I will Eating");36. state = EATING;37. }else{38. state = THINKING;39. strcpy(ptrState,"I have not chopsticks");40. sem_post(&chopsticks[left]);//释放请求的得到的left筷子41. printf("Philosopher right chopsticks is busy,right=%d,th read id is %d\n",right,id);42. }43. }else{44. printf("Philosopher left chopsticks is busy,left=%d,thread id is %d\n",left,id);//这句话由于上面被阻塞永远不会输出45. }46.break;47.case EATING:48. printf("Philosopher fetch left and right chopsticks: (%d,%d), threadid is %d\n",left,right,id);49. sem_post(&chopsticks[left]);50. sem_post(&chopsticks[right]);51. printf("Philosopher release left and right chopsticks: (%d,%d),threadid is %d\n",left,right,id);52. usleep(500);53. state = THINKING;54. strcpy(ptrState,"Thinking after eat");55.break;56. }57. pthread_mutex_lock(&mutex);58. printf("Philosopher is %s, thread id is %d\n",ptrState,id);59. pthread_mutex_unlock(&mutex);60. usleep(1000);61. }62.63. pthread_exit((void*)0);64.}65.66.int main(){67. pthread_t tid[PEOPLE_NUM];68.int i;69. pthread_mutex_init(&mutex,NULL);70.for(i = 0 ; i < PEOPLE_NUM ; i ++){71. sem_init(&chopsticks[i],0,1);72. }73.for(i = 0 ; i < PEOPLE_NUM ; i ++){74. pthread_create(&tid[i],NULL,philosopher,(void*)i);75. }76.for(i = 0 ; i < PEOPLE_NUM ; i ++){77. pthread_join(tid[i],NULL);78. }79.return 0;}#include#include#include#include#include#include#include#include#define N 5 //哲学家的人数#define LEFT (i+N-1)%N //i的左边邻居编号#define RIGHT (i+1)%N //i的右边邻居编号#define THINKING 0 //哲学家在思考#define HUNGRY 1 //哲学家试图拿起叉子#define EATING 2 //哲学家进餐int mutex; //缓冲区信号量（含有1个）) int semphilosopher; //哲学家状态信号量(含有5个)char *state; //哲学家状态int shmid; //共享内存区union semun { //对信号量控制的命令参数int val;struct semid_ds *buf;ushort *array;}arguement;int newshm(){shmid = shmget(IPC_PRIVATE, N, IPC_CREAT|0660);if(shmid < 0){return 0;}return 1;}int doshmat(){state = (char*)shmat(shmid, (void*)0, 0);if(state == (void*)-1){return 0;}return 1;}int newsem(){//每个哲学家的信号量初始化为0arguement.val = 0;semphilosopher = semget(IPC_PRIVATE, N, IPC_CREAT|0660);//创建一个哲学家信号量集合if(semphilosopher == -1) { printf("create semphilosopher error!n"); return0;}for(int i=0; i<="" p="">{if (semctl(semphilosopher,i,SETVAL,arguement) <0)//（semphilosopher,i）表示控制信号量集合中的第i个信号量return 0;}//缓冲区的信号量初始化为1arguement.val = 1;mutex = semget(IPC_PRIVATE,1,IPC_CREAT|0660);if (mutex < 0) return 0;if (semctl(mutex,0,SETVAL,arguement) < 0)return 0;return 1;}void p_operator(int semid, int member)//P操作{struct sembuf sem_op={ member, -1, SEM_UNDO };semop(semid, &sem_op, 1);}void v_operator(int semid, int member)//V操作{struct sembuf sem_op={ member, 1, SEM_UNDO };semop(semid, &sem_op, 1);}void think(int i){state[i] = THINKING;printf("philosopher%d is thinking!n",i);sleep(3);}void eat(int i){printf("philosopher%d is eating!n",i);sleep(3);}void finish(int i){printf("philosopher%d has ended eating!n",i);sleep(2);}void test(int i){if (state[i]==HUNGRY && state[LEFT]!=EATING && state[RIGHT]!=EATING){state[i] = EATING;printf("philosopher%d has took two forks and will start eating!n",i);v_operator(semphilosopher, i);}}void take_forks(int i){p_operator(mutex, 0);state[i] = HUNGRY;test(i);v_operator(mutex, 0);p_operator(semphilosopher, i); }void put_forks(int i){p_operator(mutex, 0);state[i] = THINKING;test(LEFT);test(RIGHT);v_operator(mutex, 0);}void philosopher(int i){think(i);take_forks(i);eat(i);put_forks(i);finish(i);think(i);}main(){int current,pc;if(newshm()==0){printf("newshm error!n"); return 1;}if(doshmat()==0){printf("newshm error!n");return 1;}if(newsem()==0){printf("newsem error!n");return 1;}for(int i=0; i<="" p="">{while((pc=fork())<0);if(pc == 0){current = i;break;}}if(pc > 0){wait(state);shmctl(mutex, IPC_RMID, 0); //删除与第一个参数对应的物理存储空间shmctl(semphilosopher, IPC_RMID, 0);shmdt(state); //切断逻辑地址与内存的联系shmctl(shmid, IPC_RMID, 0);printf("all child process ended!n");}elsephilosopher(current);exit(0);}。
哲学家就餐问题python
哲学家就餐问题python哲学家就餐问题是一个经典的并发问题，主要涉及到五个哲学家坐在圆桌旁，只有五支筷子，他们思考、拿起筷子、放下筷子都需要时间。
如果两个哲学家同时拿起相邻的两只筷子，就会死锁，因为总会有一个哲学家等待另一只筷子。
以下是一个Python实现的例子：python复制代码import threadingimport randomclass DiningPhilosophers:def__init__(self, n):self.forks = [threading.Lock() for _ in range(n)]self.philosophers = [threading.Thread(target=self.think_and_eat, args=(i,)) for i in range(n)]for philosopher in self.philosophers:philosopher.start()def think_and_eat(self, i):while True:self.think(i)self.eat(i)def think(self, i):print(f"Philosopher {i} is thinking")time.sleep(random.random()) # Thinking takes timedef eat(self, i):left = (i - 1) % 5# Left forkright = (i + 1) % 5# Right forkprint(f"Philosopher {i} is eating")with self.forks[left], self.forks[right]: #拿起左右两边的叉子time.sleep(random.random()) # Eating takes timeprint(f"Philosopher {i} is done eating")# 运行5个哲学家dining_philosophers = DiningPhilosophers(5)在这个实现中，我们使用了Python的threading模块来创建和运行线程，并且每个哲学家都有自己的思考和吃饭的线程。
操作系统-哲学家就餐问题生产者消费者问题
实验题目：在BACI并发程序设计系统中实现哲学家就餐问题和生产者/消费者问题一、BACI简介：BACI提供了一个可以编写并发程序的环境，在这个平台上，我们可以很容易的模拟程序的并发执行，在这种并行的编译环境中，可以把BACI中的一些语句嵌入到C++，C，Java 等高等程序中，使程序可以并行执行 .基于C++的BACI语法(C—BACI Compiler)该语法结构是在C++语法结构的基础上，增加一些并发语句扩展而来，一下是一些常用的并发语句1. cobegin函数在BACI系统中，并发进程与并发线程同步，多个进程可以并发的在cobegin 块中来并发执行，该函数必须在主函数中，语法结构为：cobegin {proc1(...);proc2(...);. . . . procN(...);}其中每个进程并发随机执行，每次执行的顺序可能会不一样，当所有的进程接受后，该函数结束。
2. Semaphores/Binarysem信号量的(Semaphores)机制可以更方便的实现进程同步，Semaphores是一种如C 中”int”一样的类型，可以用来定义信号量类型的变量，Binarysem是一种二进制信号量，它所定义的变量只能取1或0，用来表示互斥。
1).信号量的声明和初始化semaphores a;binarysem s;上面声明了两个信号量a，b，其中b为二进制信号量信号量按如下方式初始化：Initialsem(semaphores , interger);Initialsem(binarysem , 0/1);2)P(wait)/V(signal)函数强大的PV操作与信号量一次很方便的解决了并发进程同步与互斥问题函数原型：void p(semaphores &s); or void wait(semaphores &s);void v(semaphores &s); or void signal(semaphores &s);函数说明：p(sem): 如果sem > 0,则sem减1，调用P的进程可以继续执行，如果sem=0，则该进程阻塞，该函数操作是原子性的.v(sem): 如果v=0，或有进程阻塞，则将其唤醒，如果没有进程等待，将sem加1，在任何时候调用v的进程可以继续执行，其操作也是原子的.3.atomicatomic关键字定义了原子操作，即该函数操作不可剥夺，每次只能一个进程访问用法：在要原子执行的函数前加atomic即可，如：atomic int sum(){. . . ..}则sum()函数就可以原子操作了4.void suspend(void)suspend函数将调用的线程挂起5.void revive (int process_number)该函数用于唤醒某个进程，其进程号为process_number二、BACI开发过程：1、开发环境：Ubuntu 10.042、开发工具：采用带有GUI的BACI工具软件，下载地址：/fs_home/tcamp/baci/index.html3、解压后的目录：4、实验测试过程（a）软件测试用例：源代码：jqk.cm测试结果：（b）：生产者消费者问题(Bounded-Buffer)在BACI系统中模拟生产者，消费者问题，用PV操作实现同步，与互斥源代码(ex1.cm):在终端进行编译：运行GUI运行结果：(c)：哲学家就餐问题(Dining-Philosophers) 源代码：ex2.cm编译运行GUI：运行结果：三、实验总结在本次实验过程中，选定题目后便在网上搜索资料，最终选定了较为简单的BACI测试工具，然后简单学习了一下BACI的语法规则和一些常用的函数，进而编写代码测试实验。
操作系统哲学家就餐问题实验报告
操作系统哲学家就餐问题实验报告实验目的：通过实验探究操作系统中的哲学家就餐问题，了解并掌握解决该问题的不同算法。
实验原理：哲学家就餐问题是一个典型的并发控制问题，该问题描述了一群哲学家围坐在圆桌上，每个哲学家左右两边各有一只筷子，哲学家只有同时拿到左右两只筷子时才能进餐，进餐完毕后将筷子放回桌面。
该问题的解决涉及到互斥、死锁、饥饿等并发问题。
实验步骤：1. 实现基于信号量的解法：- 为每个哲学家和筷子创建一个信号量；- 哲学家进入就餐前先检查左右两只筷子是否可用；- 若可用，则将左右两只筷子设置为不可用，并进餐；- 进餐完毕后将左右两只筷子设置为可用。
2. 实现基于管程的解法：- 哲学家类中定义进餐和放下筷子的方法；- 使用一个互斥锁来确保每次只有一个哲学家能进入管程；- 当某个哲学家想要进餐时，先检查是否有足够的筷子可用；- 若可用，则进入进餐方法，将筷子设置为不可用，并开始进餐； - 进餐完毕后，释放筷子并通知其他哲学家。
3. 运行实验程序，观察哲学家的就餐过程。
4. 分析实验结果，比较两种算法的优缺点。
实验结果与分析：通过观察实验程序运行的结果，可以发现在基于信号量的解法中，哲学家的就餐过程是以并发的方式进行的，每个哲学家在不产生死锁的前提下获取到筷子并进餐。
但是，由于每个哲学家只能同时拿到一只筷子，有可能会出现饥饿的情况，即某个哲学家一直无法获取到筷子进餐。
而基于管程的解法则能够避免饥饿的问题，每个哲学家在进餐前都会检查是否有足够的筷子可用，若不可用则等待。
通过互斥锁的使用，确保每次只有一个哲学家能够进入管程进行操作，避免了并发产生的问题。
综上所述，基于管程的解法相对于基于信号量的解法更加可靠，能够避免饥饿问题的出现。
但是在实际应用中，两种解法的选择还需要根据具体情况进行权衡和取舍。
用c语言实现哲学家进餐的问题
用C语言实现哲学家进餐的问题设有5个哲学家,共享一张放油把椅子的桌子,每人分得一吧椅子.但是桌子上总共执友支筷子,在每个人两边分开各放一支.哲学家只有在肚子饥饿时才试图分两次从两边拾起筷子就餐.就餐条件是:1)哲学家想吃饭时,先提出吃饭的要求;2)提出吃饭要求,并拿到支筷子后,方可吃饭;3)如果筷子已被他人获得,则必须等待该人吃完饭之后才能获取该筷子;4)任一哲学家在自己未拿到2支筷子吃饭之前,决不放下手中的筷子;5)刚开始就餐时,只允许2个哲学家请求吃饭.试问:1)描述一个保证不会出现两个邻座同时要求吃饭的算法;2)描述一个既没有两邻座同时吃饭,又没有人饿死的算法;3)在什么情况下,5个哲学家全都吃不上饭?哲学家进餐问题是典型的同步问题.它是由Dijkstra提出并解决的.该问题是描述有五个哲学家,他们的生活方式是交替地进行思考和进餐.哲学家们共用一张圆桌,分别坐在周围的五张椅子上.在圆桌上有五个碗和五支筷子,平时一个哲学家进行思考,饥饿时便试图取用其左右岁靠近他的筷子,只有在他拿到两支筷子时才能进餐.进餐完毕,放下筷子继续思考.利用记录型信号量解决哲学家进餐问题经分析可知,筷子是临界资源,在一段时间只允许一个哲学家使用.因此,可以用一个信号量表示一支筷子,由这五个信号量构成信号量数组.其描述如下:var chopstick:array[0,...,4]of semaphore;所有信号量被初始化为1,第i个哲学家的活动可描述为:repeatwait(chopstick);wait(chopstick[(i+1) mod 5]);...eat;...signal(chopstick);signal(chopstick[(i+1) mod 5]);...think;until false;在以上描述中,哲学家饥饿时,总是先去拿他左边的筷子,即执行wait(chopstick);成功后,再去拿他右边的筷子,即执行wait(chopstick[(i+1) mod 5]);,再成功后便可进餐.进餐完毕,又先放下他左边的筷子,然后放下他右边的筷子.虽然,上述解法可保证不会有两个相临的哲学家同时进餐,但引起死锁是可能的.假如五个哲学家同时饥饿而各自拿起右边的筷子时,就会使五个信号量chopstick均为0;当他们试图去拿右边的筷子时,都将因无筷子可拿而无限期地等待.对于这样的死锁问题可采用以下集中解决方法:(1)至多只允许四个哲学家同时进餐,以保证至少有一个哲学家能够进餐,最终总会释放出他所使用过的两支筷子,从而可使更多的哲学家进餐.(2)仅当哲学家的左右两支筷子都可用时,才允许他拿起筷子进餐.(3)规定奇数号的哲学家先拿起他左边的筷子,然后再去拿他右边的筷子;而偶数号的哲学家则相反.按此规定,将是1,2号哲学家竞争1号筷子,3,4号哲学家竞争3号筷子.即五个哲学家都竞争奇数号筷子,获得后,再去竞争偶数号筷子,最后总会有一个哲学家能获得两支筷子而进餐.看了整整一个上午的操作系统，看得头都大了。
多线程经典哲学家就餐问题C++113种实现
多线程经典哲学家就餐问题C++113种实现哲学家就餐问题核⼼是 避免死锁1. 同时拿起左右叉⼦class DiningPhilosophers {public:DiningPhilosophers(){}void wantsToEat(int philosopher,function<void()> pickLeftFork,function<void()> pickRightFork,function<void()> eat,function<void()> putLeftFork,function<void()> putRightFork){int r =(philosopher+1)%5;mtx.lock();// 要么左右⼀起拿，要么都不拿lock[philosopher].lock();lock[r].lock();pickLeftFork();pickRightFork();mtx.unlock();eat();putRightFork();putLeftFork();lock[r].unlock();lock[philosopher].unlock();}private:std::mutex lock[5];std::mutex mtx;};2. 改变就餐策略（奇数先拿右，偶数先拿左）class DiningPhilosophers {public:DiningPhilosophers(){}void wantsToEat(int philosopher,function<void()> pickLeftFork, function<void()> pickRightFork, function<void()> eat,function<void()> putLeftFork, function<void()> putRightFork){ int l = philosopher;int r =(philosopher+1)%5;if(philosopher &1){lock[r].lock();lock[l].lock();pickRightFork();pickLeftFork();}else{lock[l].lock();lock[r].lock();pickLeftFork();pickRightFork();}eat();putLeftFork();putRightFork();lock[l].unlock();lock[r].unlock();}private:std::mutex lock[5];};3. 限定就餐⼈数（4个⼈就餐）class Semaphore {public:Semaphore(){}void set_count(int k){count = k;}void signal(){unique_lock<std::mutex>lock(mtx);++count;cv.notify_one();}void wait(){unique_lock<std::mutex>lock(mtx);while(count <=0)cv.wait(lock);--count;}private:int count;std::mutex mtx;std::condition_variable cv;};class DiningPhilosophers {public:DiningPhilosophers(){sem.set_count(4);}void wantsToEat(int philosopher,function<void()> pickLeftFork, function<void()> pickRightFork, function<void()> eat,function<void()> putLeftFork, function<void()> putRightFork){ int l = philosopher;int r =(philosopher+1)%5;sem.wait();lock[l].lock();lock[r].lock();pickLeftFork();pickRightFork();eat();putLeftFork();putRightFork();lock[l].unlock();lock[r].unlock();sem.signal();}private:Semaphore sem;std::mutex lock[5];};。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
while (true)
{
switch(mystate)
{
case THINKING:
mystate = HUNGRY; // 改变状态
strcpy(stateStr, "HUNGRY");
strcpy(stateStr, "THINKING");
break;
}
// 输出状态
WaitForSingleObject(mutex, INFINITE);
cout << "philosopher " << myid << " is : " << stateStr << endl;
ReleaseMutex(mutex);
// sleep a random time : between 1 - 5 s
int sleepTime;
sleepTime = 1 + (int)(5.0*rand()/(RAND_MAX+1.0));
Sleep(sleepTime*10);
/*HANDLE(句柄)是windows操作系统中的一个概念。指的是一个核心对象在某一个进程中的唯一索引*/
HANDLE semaphore[PHILOSOPHER_NUM]; // semaphore 用来表示筷子是否可用
HANDLE mutex; // Mutex用来控制安全输出
DWORD WINAPI philosopherProc( LPVOID lpParameter) //返回 DWORD（32位数据）的 API 函数philosopherProc
{
int myid;
char idStr[128];
char stateStr[128];
char mystate;
int ret;
unsigned int leftFork; //左筷子
unsigned int rightFork; //右筷子
myid = int(lpParameter);
itoa(myid, idStr, 10);
{
ret = WaitForSingleObject(semaphore[rightFork], 0); //左筷子可用就拿起，再检查右筷子是否可用
if (ret == WAIT_OBJECT_0)
{
mystate = DINING; // 右筷子可用，就改变自己的状态
ReleaseSemaphore(semaphore[leftFork], 1, NULL);
ReleaseSemaphore(semaphore[rightFork], 1, NULL);
mystate = THINKING; // 改变自己的状态
{
semaphore[i] = CreateSemaphore(NULL, 1, 1, NULL);
hPhilosopher[i]=CreateThread(NULL,0,philosopherProc,LPVOID(i), CREATE_SUSPENDED,0);
}
for (i=0; i<PHILOSOPHER_NUM; i++)
#include <stdio.h>
#include <iostream>
using namespace std; //命名空间std内定义的所有标识符都有效
const unsigned int PHILOSOPHER_NUM=5; //哲学家数目
ResumeThread(hPhilosopher[i]);
Sleep(2000);
return 0;
}
strcpy(stateStr, "DINING");
}
else
{
ReleaseSemaphore(semaphore[leftFork], 1, NULL); // 如果右筷子不可用，就把左筷子放下
}
}
break;
case DINING:
// 吃完后把两支筷子都放下
WaitForSingleObject(mutex, INFINITE);
cout << "philosopher " << myid << " begin......" << endl;
ReleaseMutex(mutex);
myeftFork = (myid) % PHILOSOPHER_NUM;
rightFork = (myid + 1) % PHILOSOPHER_NUM;
//哲学家就餐问题的解法
#include <windows.h>
#include <process.h>
#include <time.h>
#include <stdlib.h>
break;
case HUNGRY:
strcpy(stateStr, "HUNGRY");
ret = WaitForSingleObject(semaphore[leftFork], 0); // 先检查左筷子是否可用
if (ret == WAIT_OBJECT_0)
const char THINKING=1; /*标记当前哲学家的状态,1表示等待,2表示得到饥饿,3表示正在吃饭*/
const char HUNGRY=2;
const char DINING=3;
HANDLE hPhilosopher[5]; //定义数组存放哲学家
}
}
int main()
{
int i;
srand(time(0));
mutex = CreateMutex(NULL, false, NULL);
for (i=0; i<PHILOSOPHER_NUM; i++)