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：筷子的编号。
筷子的主要方法如下：
哲学家类的成员变量如下。
分别代表哲学家左边的筷子，右边的筷子。
左边的邻座，右边的邻座。
哲学家的编号，已经吃了的次数。
dinningExam是Applet的类，为了调用repaint()，更新界面。
Thread则是线程的一个实例变量。
哲学家的方法如下。
在写代码时，对原算法做了一定程度的简化，所实现的方案如下。
1. 筷子本身没有被申请使用的接口，任何一个哲学家，向他的邻座申请筷子（调用answer接口）。若筷子是脏的，则邻座把筷子擦干净给他。否则不给。邻座给筷子的过程要同步执行。
2. 哲学家吃饭的方法是eating，假设每人吃饭的时间是3秒（slee的时间）。
3. 哲学家的主函数（run）
(1) 每个哲学家申请所没有的筷子，为了避免能导致死锁的特定初态，使用了一个随机数Random。
(2) 哲学家两个筷子都有了之后，开始吃饭。这个步骤要同步。否则容易发生错误。
(3) 吃完饭之后，哲学家随机思考一段时间：Thread.sleep(sleepSec % 500);。
敬请指正。
哲学家就餐问题，是并行程序中的一个经典问题，其描述如下。
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：筷子的编号。
筷子的主要方法如下：
|
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;
}
|
哲学家类的成员变量如下。
|
1
2
3
4
5
|
Stick leftStick, rightStick;
Philo leftPhilo, rightPhilo;
int
number, eatTimes;
DinningPhi dinningExam;
Thread t;
|
分别代表哲学家左边的筷子，右边的筷子。
左边的邻座，右边的邻座。
哲学家的编号，已经吃了的次数。
dinningExam是Applet的类，为了调用repaint()，更新界面。
Thread则是线程的一个实例变量。
哲学家的方法如下。
|
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);。
敬请指正。
扫一扫
1737
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
