哲学家就餐问题与死锁总结

Posted 2023-04-25

参考技术A

死锁的四个条件：
（1） 互斥条件：一个资源每次只能被一个进程使用。
（2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系

先写一个会造成死锁的哲学家问题。当所有哲学家同时决定进餐，拿起左边筷子时候，就发生了死锁。

解决方案一：破坏死锁的 循环等待条件 。
不再按左手边右手边顺序拿起筷子。选择一个固定的全局顺序获取，此处给筷子添加id，根据id从小到大获取，(不用关心编号的具体规则，只要保证编号是全局唯一并且有序的)，不会出现死锁情况。

方法二：破坏死锁的 请求与保持条件 ，使用lock的特性，为获取锁操作设置超时时间。这样不会死锁（至少不会无尽的死锁）

方法三：设置一个条件遍历与一个锁关联。该方法只用一把锁，没有chopstick类，将竞争从对筷子的争夺转换成了对状态的判断。仅当左右邻座都没有进餐时才可以进餐。提升了并发度。前面的方法出现情况是：只有一个哲学家进餐，其他人持有一根筷子在等待另外一根。这个方案中，当一个哲学家理论上可以进餐（邻座没有进餐），他肯定可以进餐。

哲学家就餐问题

哲学家就餐问题是1965年由Dijkstra提出的一种线程同步的问题。

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

解决办法：

　　1、添加一个服务生，只有当经过服务生同意之后才能拿筷子，服务生负责避免死锁发生。

　　2、每个哲学家必须确定自己左右手的筷子都可用的时候，才能同时拿起两只筷子进餐，吃完之后同时放下两只筷子。

　　3、规定每个哲学家拿筷子时必须拿序号小的那只，这样最后一位未拿到筷子的哲学家只剩下序号大的那只筷子，不能拿起，剩下的这只筷子就可以被其他哲学家使用，避免了死锁。这种情况不能很好的利用资源。　

代码实现：实现第2种方案

public class philosopher{

    public static void main(String[] args) {
        Fork forks = new Fork();
        PhilosopherThread philosopherThread1 = new PhilosopherThread("0", forks);
        PhilosopherThread philosopherThread2 = new PhilosopherThread("1", forks);
        PhilosopherThread philosopherThread3 = new PhilosopherThread("2", forks);
        PhilosopherThread philosopherThread4 = new PhilosopherThread("3", forks);
        PhilosopherThread philosopherThread5 = new PhilosopherThread("4", forks);
        philosopherThread1.start();
        philosopherThread2.start();
        philosopherThread3.start();
        philosopherThread4.start();
        philosopherThread5.start();
    }

}

class PhilosopherThread extends Thread{
    private String name;
    private Fork forks;
    public PhilosopherThread(String name, Fork forks){
        super(name);
        this.name = name;
        this.forks = forks;
    }
    @Override
    public void run() {
        while(true){
            this.think();
            forks.getFork();
            this.eat();
            forks.freeFork();
        }
    }
    public void eat(){
        System.out.println("I am eating:" + name);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public void think(){
        System.out.println("I am thinking:" + name);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class Fork{
    boolean[] forks = new boolean[5];
    public synchronized void getFork(){
        String currentName = Thread.currentThread().getName();
        int index = Integer.parseInt(currentName);
        // 如果哲学家左右的勺子不都能拿，则继续等待
        while(forks[index] || forks[(index + 1) % 5]){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        forks[index] = true;
        forks[(index + 1) % 5] = true;
    }
    public synchronized void freeFork(){
        String currentName = Thread.currentThread().getName();
        int index = Integer.parseInt(currentName);
        forks[index] = false;
        forks[(index + 1) % 5] = false;
        notifyAll();
    }
}