哲学家就餐问题，是并行程序中的一个经典问题，其描述如下。
1. 圆桌上有五位哲学家，每两人中间有一个筷子。
2. 每个哲学家有两件事情要做：
(1) 思考；
(2) 吃饭。哲学家必须同时拿到两只筷子，才能吃饭。
3. 哲学家之间并不知道对方何时要吃饭，何时要思考，不能协商制定分时策略。
4. 设计一个拿筷子的策略，使得哲学家之间不会因为拿筷子而出现死锁或者活锁。
下图为一个哲学家和筷子的示意图，也是我编的java程序的界面。比较简陋，不过用来示意，还是看得明白的，呵呵。
其中，方块代表哲学家，黄线表示筷子。方块中的数字代表哲学家已经用餐的次数（若一个哲学家的就餐次数一直为0，则是饿死状态），初始化都为0。
2 几种经典解法
1. 资源分级的解法。
为资源（也就是筷子）分配一个偏序结构，所有资源都必须按顺序访问，也即拿起筷子必须按照一定的顺序，比如：先拿编号较小的筷子，再拿编号较大的筷子。放下筷子的顺序则无所谓。这种方法可以避免死锁。例如，若每个人都拿起身边的小号的筷子，则五号筷子就没有人拿。
这种方法的效率底下。因为对于实际的问题来说，一些计算机程序事先并不知道自己所要求的资源都有哪些。那么，假若它们拿了3、4、5号资源之后，若发现需要拿2号资源，则必须先释放3、4、5号资源，才能拿到2号资源，效率十分低下。
2. 仲裁者解决方案
引入一个服务员（仲裁者）。为了拿到筷子，哲学家必须向服务员发送请求。服务员每次只服务一个哲学家，直到他拿起两只筷子为止。服务员可以使用mutex实现，这种方法限制了并行性，也即限制了在筷子允许的情况下，多个哲学家同时吃饭的可能性。若一个哲学家在吃饭，而他的邻座发起了请求，则其他的哲学家必须等到邻座拿到了2只筷子之后才能吃饭，即便他们面前的筷子是空闲的。
3. Chandy/Misra方法
完全的分布式的方法，不需要仲裁者，但是需要哲学家之间进行一些交流，其描述如下。
(1) 首先，给哲学家编号。
(2) 若两个哲学家竞争同一个筷子的时候，把筷子给编号比较小的人。
(3) 筷子有两个状态，净的和脏的。初始状态下，所有的筷子都是脏的。
(4) 哲学家要吃饭时必须拿起两只筷子，当他缺乏某只筷子的时候，发起请求。
(5) 若拿着筷子的哲学家受到了请求，如果筷子是干净的，则他不放下筷子；若是脏的，则放下筷子，并且在放下之前，把筷子擦干净。
(6) 哲学家吃完的时候，筷子变脏，当他有邻座请求筷子的时候，擦干净筷子，然后给邻座。
这种方法可以解决大规模的并发问题，也能避免饿死问题。但是，不能完全避免死锁现象（当每个哲学家拿到一只干净筷子的时候，则陷入了死锁）。
3 java实现
我实现了Chandy/Misra方法。如同该算法描述的一样，不能完全避免死锁，但是可以有较大规模的并行。下面是一个运行时刻的截图。
图中表示，有两个哲学家吃了15次饭，3个哲学家吃了14次，现在有两个哲学家正在吃饭。
实现时，主要用了两个类：筷子类Stick和哲学家类Philo。
筷子类有三个成员变量。
Owner：筷子的所有者；
dirty：筷子干净与否；
number：筷子的编号。
筷子的主要方法如下：
public synchronized void setStatus(boolean status){
dirty = status;
}
public synchronized boolean getStatus(){
return this.dirty;
}
public synchronized void setOwner(int owner){
this.owner = owner;
}
public synchronized int getOwner(){
return owner;
}
哲学家类的成员变量如下。
Stick leftStick, rightStick;
Philo leftPhilo, rightPhilo;
int number, eatTimes;
DinningPhi dinningExam;
Thread t;
分别代表哲学家左边的筷子，右边的筷子。
左边的邻座，右边的邻座。
哲学家的编号，已经吃了的次数。
dinningExam是Applet的类，为了调用repaint()，更新界面。
Thread则是线程的一个实例变量。
哲学家的方法如下。
public boolean answer(Stick used){
boolean retFlag = false;
synchronized(this){
if(used.getStatus()){
if(used == leftStick)
used.setOwner(leftPhilo.number);
else if(used == rightStick)
used.setOwner(rightPhilo.number);
else{
System.out.println("Error status!");
retFlag = false;
}
used.setStatus(false);
retFlag = true;
}
else
retFlag = false;
}
if(retFlag)
dinningExam.repaint();
return retFlag;
}
public void eating(){
try{
Thread.sleep(3000);
}catch(InterruptedException ie){
System.out.println("Catch an Interrupted Exception!");
return;
}
leftStick.setStatus(true);
rightStick.setStatus(true);
eatTimes++;
dinningExam.repaint();
return;
}
public void run(){
Random r = new Random();
int intR;
while(true){
while(leftStick.getOwner() != number | rightStick.getOwner() != number){
intR = r.nextInt();
if(intR % 2 == 0 & leftStick.getOwner() != number)
leftPhilo.answer(leftStick);
else if(intR % 2 == 1 & rightStick.getOwner() != number)
rightPhilo.answer(rightStick);
}
synchronized(this){
if(leftStick.getOwner() == number
& rightStick.getOwner() == number){
eating();
}
}
try{
int sleepSec = r.nextInt();
if(sleepSec < 0)
sleepSec = -sleepSec;
Thread.sleep(sleepSec % 500);
}catch(InterruptedException ie){
System.out.println("Catch an Interrupted Exception!");
}
}
}
在写代码时，对原算法做了一定程度的简化，所实现的方案如下。
1. 筷子本身没有被申请使用的接口，任何一个哲学家，向他的邻座申请筷子（调用answer接口）。若筷子是脏的，则邻座把筷子擦干净给他。否则不给。邻座给筷子的过程要同步执行。
2. 哲学家吃饭的方法是eating，假设每人吃饭的时间是3秒（slee的时间）。
3. 哲学家的主函数（run）
(1) 每个哲学家申请所没有的筷子，为了避免能导致死锁的特定初态，使用了一个随机数Random。
(2) 哲学家两个筷子都有了之后，开始吃饭。这个步骤要同步。否则容易发生错误。
(3) 吃完饭之后，哲学家随机思考一段时间：Thread.sleep(sleepSec % 500);。
敬请指正。
