哲学家就餐问题及其一种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);。