哲学家就餐问题及其一种java多线程实现

1 概述

哲学家就餐问题，是并行程序中的一个经典问题，其描述如下。

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);。