Java Thread模拟哲学家进餐

来源：互联网发布：55开的淘宝店编辑：程序博客网时间：2024/06/06 09:58

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：筷子的编号。
筷子的主要方法如下：

Java code
?
1
2
3
4
5
6
7
8
9
10
11
12
    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;  
    }  

哲学家类的成员变量如下。

Java code
?
1
2
3
4
5
Stick leftStick, rightStick;  
Philo leftPhilo, rightPhilo;  
int number, eatTimes;  
DinningPhi dinningExam;  
Thread t; 

分别代表哲学家左边的筷子，右边的筷子。
左边的邻座，右边的邻座。
哲学家的编号，已经吃了的次数。
dinningExam是Applet的类，为了调用repaint()，更新界面。
Thread则是线程的一个实例变量。
哲学家的方法如下。

Java code
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
    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);。

敬请指正。

0 0