正文
Java哲学家进餐问题|多线程
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
Java实验三 多线程
哲学家进餐问题
5个哲学家共用一张圆桌，分别坐在周围的5张椅子上，
在圆桌上有5个碗和5只筷子（注意是5只筷子，不是5双），
碗和筷子交替排列。他们的生活方式是交替地进行思考（thinking）和进餐（eating）。
平时，一个哲学家进行思考，饥饿时便试图取用其左右最靠近他的两只筷子，规定他必须先取左边的筷子，再取右边的筷子。
只有在他拿到两只筷子时才能进餐。
进餐完毕，放下筷子继续进行思考。
假如5位哲学家同时饥饿，各自拿起左边的筷子时，再去拿各自右边的筷子，因为无筷子可拿而陷入无期限等待（死锁）。
进餐完毕释放他用过的两只筷子，从而使更多的哲学家能够进餐。使用Java的多线程同步技术，实现上述解决方案。
解决方法一：破坏循环等待条件
最多允许4个哲学家同时去拿左边的筷子 ，即死锁四大必要条件之一——破坏循环等待条件。
synchronized关键字易混淆处：
用法：synchronized(一个对象){同步代码块}
这里synchronized锁住的不是这"一个对象"，而是用这"一个对象"来当看门人，只允许一个线程来进入synchronized锁住的同步{代码块}，所以这个代码块被称作“同步代码块”，当代码块执行完后，会让这“一个对象”(看门人)，吼一声让其它线程进来。原理是：每一个java对象都关联了一个“ monitor lock”，当一个线程获取了 monitor lock 后,其它线程如果运行到获取同一个 monitor 的时候就会被 block 住。当这个线程执行完同步代码,则会释放 monitor lock。
下面代码，经过分析后能满足最多允许4个哲学家同时去拿左边的筷子的条件：
分析如下：
1.如果不加num<4，synchronized(left)后，如果另一个哲学家进程拿了right的筷子，另一个哲学家又拿了这个哲学家右边的筷子...依此类推，产生循环等待链，即产生死锁。就会产生死锁。
我们标记3个结点去分析各个代码块进入的最多线程数。
2.加了num<4这个条件后，可能会有5个线程，同时满足if判断语句(结点1)；而又因为synchronized了一个筷子(left)，所以最多有4个进程进入了synchronized(left){}代码块钟，执行了num++，(结点2)，那么虽然此时可能有5个进程进入了if(num<4)语句，但是第5个进程也会被阻挡在synchronized外面。在synchronized(right)后，最多有2个进程去吃东西(结点3),因为只有5个筷子，同时只能让两个人去吃，其它3个人等待，看图比较容易明白。
代码如下：
class phiPerson implements Runnable{ //实现Runnable接口
//全部使用static关键字 静态成员属于整个类，当系统第一次使用该类时，就会为其分配内存空间直到该类被卸载才会进行资源回收
//为什么用static修饰 因为多线程多个哲学家需要共享筷子这个对象
static Object[] chops;//static关键字修饰的变量 该类所有的对象共享同一个成员
static int Num = 0; //同时拿左手边筷子的人数 也是全局变量
private int pos; //当前哲学家的编号 私有变量
public phiPerson(int position,Object[] chops) { //构造函数
// TODO Auto-generated constructor stub
this.chops = chops;
this.pos = position;
}
@Override
public void run() { //重写run方法
// TODO Auto-generated method stub
while(true) {
int right = (pos+1)%5; //我右边筷子在数组中的下标
int left = (pos)%5;//左边筷子在数组中的下标
if(Num < 4) { //最多允许4个人同时拿左手边的筷子
//结点1：5个进程都有可能进入这个地方
synchronized (chops[left]) { //锁 左手边的筷子 就是等待左边的人用我左手边的筷子吃完了后我再拿来吃。。
Num++;//同时拿左手边筷子的人的数量+1 //这里没有锁住num，有可能会使得在没有num++时，5个进程都进来，
//结点2：最多4个进程进到这个地方，因为synchronized (chops[left])后，需要left筷子的另1个进程要在外面等待
System.out.println(Num);
System.out.println("第"+(pos+1)+"个哲学家拿了左手边的筷子");
synchronized(chops[right]) {//右手边的筷子 锁 就是等待右手边的筷子没人拿了我再拿
//结点3：最多有2个进程进入到这个地方，因为只有5个筷子，所以最多两个人同时拿。
System.out.println("第"+(pos+1)+"个哲学家拿了右手边的筷子");
System.out.println("第"+(pos+1)+"个哲学家正在eating");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("第"+(pos+1)+"个哲学家吃完了，把筷子放回了原处，开始thinking");
Num--;//同时拿左手边筷子的人的数量-1
}
}
}
}
}
}
public class phiEat {
public static void main(String[] args) {
// TODO Auto-generated method stub
Object [] chObject = new Object[5];
for(int i=0;i<5;i++) chObject[i] = i; //object必须要初始化一下呀
//5个哲学家
phiPerson firThread = new phiPerson(0,chObject);
phiPerson secThread = new phiPerson(1,chObject);
phiPerson thirThread = new phiPerson(2,chObject);
phiPerson fourThread = new phiPerson(3,chObject);
phiPerson fifThread = new phiPerson(4,chObject);
//开吃了
new Thread(firThread).start();
new Thread(secThread).start();
new Thread(thirThread).start();
new Thread(fourThread).start();
new Thread(fifThread).start();
}
}
解决方法二：破坏请求和保持条件
方案：仅当一个哲学家左右两边的叉子都可用时才允许他抓起叉子 ，即破坏死锁四大条件之一——请求和保持条件
说明白点就是，不会出现某个哲学家拿一个筷子等一个筷子的情况，必须同时拿两个！
package philosopher;
public class ThreadTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
Chop fiveChops = new Chop();
new Philosopher(0,fiveChops).start();
new Philosopher(1,fiveChops).start();
new Philosopher(2,fiveChops).start();
new Philosopher(3,fiveChops).start();
new Philosopher(4,fiveChops).start();
}
}
class Philosopher extends Thread{
private int index;
private Chop chop;
public Philosopher(int index, Chop chop) {
// TODO Auto-generated constructor stub
this.index = index;
this.chop = chop;
}
@Override
public void run() {
while(true) {
thinking();
chop.takeChop(index);
eating();
chop.putChop(index);
}
}
private void thinking(){
// TODO Auto-generated method stub
System.out.println("第"+index + "个哲学家正在思考...");
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private void eating(){
// TODO Auto-generated method stub
System.out.println("第"+index + "个哲学家正在吃饭...");
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class Chop {
private Boolean[] chops = {false,false,false,false,false};
public synchronized void takeChop(int index) {
// TODO Auto-generated method stub
while(chops[index] || chops[(index+1)%5]) {
try {
wait(); //拿不到筷子就会被阻塞 进入等待池 从而不会再来竞争
} catch (Exception e) {
// TODO: handle exception
}
}
chops[index] = true;
chops[(index+1)%5] = true;
}
public synchronized void putChop(int index) {
// TODO Auto-generated method stub
chops[index] = false;
chops[(index+1)%5] = false;
notifyAll();
}
}
这里产生疑问点待解决，notifyAll和wait在此代码中如何工作。
参考文章：
[1] sunny_ss12 经典同步问题（二）---哲学家就餐问题
[2] Yun_Ge PV操作经典例题——哲学家进餐问题
[3] qiuhuilu JAVA多线程学习--哲学家就餐问题
