JAVA并发，经典死锁案例-哲学家就餐

转自：http://blog.csdn.net/tayanxunhua/article/details/38691005

死锁经典案例：哲学家就餐。

这个案例会导致死锁。

通过修改《Java编程思想4》一书中的案例，来做实验，代码更易理解，结果也相对容易控制。

附代码：

筷子类：

package com.tyxh.ch21.c6;

public class Chopstick {
    private boolean taken = false;//判断是此筷子是否被拿起
    public synchronized void take() throws InterruptedException {
        while(taken) {
            //如果已被拿起，则等待
            wait();
        }
        //如果没有被拿起，则可以被拿起，并设置taken为true
        taken = true;
    }
    
    public synchronized void drop() {
        //放下筷子之后设置taken为false，并通知其他哲学家
        taken = false;
        notifyAll();
    }
}

哲学家类：

package com.tyxh.ch21.c6;

import java.util.Random;
import java.util.concurrent.TimeUnit;

public class Philosopher implements Runnable {
    private Chopstick left;//左筷子
    private Chopstick right;//右筷子
    
    private final int id;//哲学家编号
    private final int ponderFactor;//根据这个属性设置思考时间
    
    private Random rand = new Random(47);
    private void pause() throws InterruptedException {
        if(ponderFactor == 0) {
            return;
        }
        TimeUnit.MILLISECONDS.sleep(rand.nextInt(ponderFactor *250));
    }
    
    public Philosopher(Chopstick left, Chopstick right, int ident, int ponder) {
        this.left = left;
        this.right = right;
        this.id = ident;
        this.ponderFactor = ponder;
    }
    
    public void run() {
        try{
            while(!Thread.interrupted()) {
                System.out.println(this + " " + "thinking");
                pause();
                right.take();
                System.out.println(this + " " + "拿右筷子");
                left.take();
                System.out.println(this + " " + "拿左筷子");
                pause();
                System.out.println(this + " " + "吃");
                right.drop();
                System.out.println(this + " " + "放下右筷子");
                left.drop();
                System.out.println(this + " " + "放下左筷子");
            }
        }catch(InterruptedException e) {
            System.out.println(this + " 退出   ");
        }
    }
    
    public String toString() {
        return "Phiosopher : " + id; 
     }
}

测试类：

package com.tyxh.ch21.c6;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class DeadlockingDiningPhilosophers {
    public static void main(String[] args) throws InterruptedException {
        int ponder = 5;
        if(args.length > 0) {
            ponder = Integer.parseInt(args[0]);
        }
        int size = 5;
        if(args.length > 1) {
            size = Integer.parseInt(args[1]);
        }
        ExecutorService exec = Executors.newCachedThreadPool();
        Chopstick[] stick = new Chopstick[size];
        
        for(int i = 0; i < size; i++) {
            stick[i] = new Chopstick();
        }
        
        for(int i = 0; i < size; i++) {
            Philosopher p = new Philosopher(stick[i], stick[(i+1)%size], i, ponder);
            exec.execute(p);
        }
        
        TimeUnit.SECONDS.sleep(3);
        exec.shutdownNow();
        
    }
}
 

可以通过命令行参数调整ponder因子设置哲学家思考时间，也可以设置筷子及哲学家的数量size。

死锁产生的四个必要条件。

    1>互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用

    2>不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。

    3>请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的战友。

    4>循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。

当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。

这里仅给出书中处理此死锁的解决方案(破坏第四种条件)：

方案是：

前面哲学家拿筷子的顺序都是先拿右，再拿左，但最后一个哲学家拿筷子的顺序是先拿左，再拿右，就可以通过阻止循环等待这个死锁的条件来阻止死锁发生。

即将代码：

        for(int i = 0; i < size; i++) {
            Philosopher p = new Philosopher(stick[i], stick[(i+1)%size], i, ponder);
            exec.execute(p);
        }

修改为：

        for(int i = 0; i < size; i++) {
            if(i < size - 1) {
                Philosopher p = new Philosopher(stick[i], stick[(i+1)%size], i, ponder);
                exec.execute(p);
            }else {
                Philosopher p = new Philosopher(stick[0], stick[i], i, ponder);
                exec.execute(p);
            }
        }