使用Lock和Condition实现哲学家算法问题

问题

问题描述：一圆桌前坐着5位哲学家，两个人中间有一只筷子，桌子中央有面条。哲学家思考问题，当饿了的时候拿起左右两只筷子吃饭，必须拿到两只筷子才能吃饭。上述问题会产生死锁的情况，当5个哲学家都拿起自己右手边的筷子，准备拿左手边的筷子时产生死锁现象。

代码

代码逻辑：
多少个哲学家，就有多少个筷子，判断哲学家左右两边的筷子是否正在使用，如果正在被使用，则将当前哲学家阻塞起来

哲学家：

public class philosopher extends Thread{

    private String id;
    private Chopsticks chopsticks;

    public philosopher(String id, Chopsticks chopsticks){
        this.id = id;
        super.setName(id);
        this.chopsticks = chopsticks;
    }

    public void eat(){
        System.out.println("哲学家-" + id + " is eating");
        try {
            sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void think(){
        System.out.println("哲学家-" + id + " is thinking");
        try {
            sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        //think();
        chopsticks.take();
        eat();
        chopsticks.put();
    }
}

筷子类：

class Chopsticks {

    private boolean[] used;
    private int count;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public Chopsticks(int count) {
        this.count = count;
        used = new boolean[count];
        for (int i = 0; i < used.length; i++) {
            used[i] = false;
        }
    }

    public void take() {
        lock.lock();
        try {
            int i = Integer.parseInt(Thread.currentThread().getName());
            //只要左边或右边的筷子被拿走了，就一直阻塞
            while (used[i] || used[ (i+1)%count ]) {
                condition.await();
            }
            System.out.println("take: " + i + ", " + (i+1)%count);
            used[i] = true;
            used[ (i+1)%count ] = true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void put() {
        lock.lock();
        try {
            int i = Integer.parseInt(Thread.currentThread().getName());
            used[i] = false;
            used[ (i+1)%count ] = false;

            //唤醒所有阻塞的哲学家
            condition.signalAll();
            System.out.println("put: " + i + ", " + (i+1)%count);
        } finally {
            lock.unlock();
        }
    }
}

测试类：

class Test{

    public static void main(String[] args) {
        Chopsticks chopsticks = new Chopsticks(5);
        for (int i = 0; i < 5; i++) {
            new philosopher(i+"", chopsticks).start();
        }
    }
}

结果：

take: 0, 1
take: 2, 3
哲学家-2 is eating
哲学家-0 is eating
put: 0, 1
put: 2, 3
take: 1, 2
哲学家-1 is eating
take: 3, 4
哲学家-3 is eating
put: 3, 4
put: 1, 2
take: 4, 0
哲学家-4 is eating
put: 4, 0