在1971年，著名的计算机科学家艾兹格·迪科斯彻提出了一个同步问题，即假设有五台计算机都试图访问五份共享的磁带驱动器。稍后，这个问题被托尼·霍尔重新表述为哲学家就餐问题。这个问题可以用来解释死锁和资源耗尽。

问题描述

设有5个哲学家，共享一张放有5把椅子的桌子，每人分得一把椅子，但是，桌子上共有5只筷子，在每人两边各放一只，哲学家们在肚子饥饿时才试图分两次从两边拿起筷子就餐。

条件：

1）拿到两只筷子时哲学家才开始吃饭。

2）如果筷子已在他人手上，则该哲学家必须等他人吃完之后才能拿到筷子。

3）任一哲学家在自己未拿到两只筷子前却不放下自己手中的筷子。

试：

1）描述一 个保证不会出现两个邻座同时要求吃饭的通信算法。

2）描述一个即没有两个邻座同时吃饭，有没有饿死（永远拿不到筷子）的算法

哲学家就餐问题可以这样表述，假设有五位哲学家围坐在一张圆形餐桌旁，做以下两件事情之一：吃饭，或者思考。吃东西的时候，他们就停止思考，思考的时候也停止吃东西。餐桌中间有一大碗意大利面，每两个哲学家之间有一只餐叉。因为用一只餐叉很难吃到意大利面，所以假设哲学家必须用两只餐叉吃东西。他们只能使用自己左右手边的那两只餐叉。哲学家就餐问题有时也用米饭和筷子而不是意大利面和餐叉来描述，因为很明显，吃米饭必须用两根筷子。

哲学家就餐问题的演示哲学家从来不交谈，这就很危险，可能产生死锁，每个哲学家都拿着左手的餐叉，永远都在等右边的餐叉（或者相反）。

即使没有死锁，也有可能发生资源耗尽。例如，假设规定当哲学家等待另一只餐叉超过五分钟后就放下自己手里的那一只餐叉，并且再等五分钟后进行下一次尝试。这个策略消除了死锁（系统总会进入到下一个状态），但仍然有可能发生“活锁”。如果五位哲学家在完全相同的时刻进入餐厅，并同时拿起左边的餐叉，那么这些哲学家就会等待五分钟，同时放下手中的餐叉，再等五分钟，又同时拿起这些餐叉。

在实际的计算机问题中，缺乏餐叉可以类比为缺乏共享资源。一种常用的计算机技术是资源加锁，用来保证在某个时刻资源只能被一个程序或一段代码访问。当一个程序想要使用的资源已经被另一个程序锁定，它就等待资源解锁。当多个程序涉及到加锁的资源时，在某些情况下就有可能发生死锁。例如，某个程序需要访问两个文件，当两个这样的程序各锁了一个文件，那它们都在等待对方解锁另一个文件，而这永远不会发生。

哲学家就餐问题是在计算机科学中的一个经典问题，用来演示在并行计算中多线程同步时产生的问题。

考虑了四种实现的方式（A、B、C、D）： 
A．原理：至多只允许四个哲学家同时进餐,以保证至少有一个哲学家能够进餐,最终总会释 
放出他所使用过的两支筷子,从而可使更多的哲学家进餐。以下将room 作为信号量，只允 
许4 个哲学家同时进入餐厅就餐，这样就能保证至少有一个哲学家可以就餐，而申请进入 
餐厅的哲学家进入room 的等待队列，根据FIFO 的原则，总会进入到餐厅就餐，因此不会 
出现饿死和死锁的现象。 
伪码： 
semaphore chopstick[5]={1，1，1，1，1}; 
semaphore room=4; 
void philosopher(int i) 
{ 
while(true) 
{ 
think(); 
wait(room); //请求进入房间进餐 
wait(chopstick[i]); //请求左手边的筷子 
wait(chopstick[(i+1)%5]); //请求右手边的筷子 
eat(); 
signal(chopstick[(i+1)%5]); //释放右手边的筷子 
signal(chopstick[i]); //释放左手边的筷子 
signal(room); //退出房间释放信号量room 
} 
} 
B．原理：仅当哲学家的左右两支筷子都可用时,才允许他拿起筷子进餐。 
方法1：利用AND 型信号量机制实现：根据课程讲述，在一个原语中，将一段代码同时需 
要的多个临界资源，要么全部分配给它，要么一个都不分配，因此不会出现死锁的情形。当 
某些资源不够时阻塞调用进程;由于等待队列的存在，使得对资源的请求满足FIFO 的要求， 
因此不会出现饥饿的情形。 
伪码： 
semaphore chopstick[5]={1，1，1，1，1}; 
void philosopher(int I) 
{ 
while(true) 
{ 
think(); 
Swait(chopstick[(I+1)]%5,chopstick[I]); 
eat(); 
Ssignal(chopstick[(I+1)]%5,chopstick[I]); 
} 
} 
方法2：利用信号量的保护机制实现。通过信号量mutex对eat（）之前的取左侧和右侧筷 
子的操作进行保护，使之成为一个原子操作，这样可以防止死锁的出现。 
伪码： 
semaphore mutex = 1 ; 
semaphore chopstick[5]={1，1，1，1，1}; 
void philosopher(int I) 
{ 
while(true) 
{ 
think(); 
wait(mutex); 
wait(chopstick[(I+1)]%5); 
wait(chopstick[I]); 
signal(mutex); 
eat(); 
signal(chopstick[(I+1)]%5); 
signal(chopstick[I]); 
} 
} 
C． 原理：规定奇数号的哲学家先拿起他左边的筷子,然后再去拿他右边的筷子;而偶数号 
的哲学家则相反.按此规定,将是1,2号哲学家竞争1号筷子,3,4号哲学家竞争3号筷子.即 
五个哲学家都竞争奇数号筷子,获得后,再去竞争偶数号筷子,最后总会有一个哲学家能获 
得两支筷子而进餐。而申请不到的哲学家进入阻塞等待队列，根FIFO原则，则先申请的哲 
学家会较先可以吃饭，因此不会出现饿死的哲学家。 
伪码： 
semaphore chopstick[5]={1，1，1，1，1}; 
void philosopher(int i) 
{ 
while(true) 
{ 
think(); 
if(i%2 == 0) //偶数哲学家，先右后左。 
{ 
wait (chopstick[ i + 1 ] mod 5) ; 
wait (chopstick[ i]) ; 
eat(); 
signal (chopstick[ i + 1 ] mod 5) ; 
signal (chopstick[ i]) ; 
} 
Else //奇数哲学家，先左后右。 
{ 
wait (chopstick[ i]) ; 
wait (chopstick[ i + 1 ] mod 5) ; 
eat(); 
signal (chopstick[ i]) ; 
signal (chopstick[ i + 1 ] mod 5) ; 
} 
} 
D．利用管程机制实现（最终该实现是失败的，见以下分析）： 
原理：不是对每只筷子设置信号量，而是对每个哲学家设置信号量。test()函数有以下作 
用： 
a. 如果当前处理的哲学家处于饥饿状态且两侧哲学家不在吃饭状态，则当前哲学家通过 
test()函数试图进入吃饭状态。 
b. 如果通过test()进入吃饭状态不成功，那么当前哲学家就在该信号量阻塞等待，直到 
其他的哲学家进程通过test()将该哲学家的状态设置为EATING。 
c. 当一个哲学家进程调用put_forks()放下筷子的时候，会通过test()测试它的邻居， 
如果邻居处于饥饿状态，且该邻居的邻居不在吃饭状态，则该邻居进入吃饭状态。 
由上所述,该算法不会出现死锁，因为一个哲学家只有在两个邻座都不在进餐时，才允 
许转换到进餐状态。 
该算法会出现某个哲学家适终无法吃饭的情况，即当该哲学家的左右两个哲学家交替 
处在吃饭的状态的时候，则该哲学家始终无法进入吃饭的状态，因此不满足题目的要求。 
但是该算法能够实现对于任意多位哲学家的情况都能获得最大的并行度，因此具有重要 
的意义。 
伪码： 
#define N 5  
#define LEFT (i-1+N)%N  
#define RIGHT (i+1)%N  
typedef enum { THINKING, HUNGRY, EATING } phil_state;  
monitor dp  
{ 
phil_state state[N]; 
semaphore mutex =1; 
semaphore s[N];  
void test(int i) 
{ 
if ( state[i] == HUNGRY &&state[LEFT(i)] != EATING && 
state[RIGHT(i)] != EATING ) 
{ 
state[i] = EATING; 
V(s[i]); 
} 
} 
void get_forks(int i) 
{ 
P(mutex); 
state[i] = HUNGRY; 
test(i);  
V(mutex); 
P(s[i]);  
} 
void put_forks(int i) 
{ 
P(mutex); 
state[i]= THINKING; 
test(LEFT(i));  
test(RIGHT(i));  
V(mutex); 
} 
} 
哲学家进程如下： 
void philosopher(int process) 
{ 
while(true) 
{ 
think(); 
get_forks(process); 
eat(); 
put_forks(process); 
} 
}