LeetCode——哲学家进餐问题

Q：5 个沉默寡言的哲学家围坐在圆桌前，每人面前一盘意面。叉子放在哲学家之间的桌面上。（5 个哲学家，5 根叉子）
所有的哲学家都只会在思考和进餐两种行为间交替。哲学家只有同时拿到左边和右边的叉子才能吃到面，而同一根叉子在同一时间只能被一个哲学家使用。每个哲学家吃完面后都需要把叉子放回桌面以供其他哲学家吃面。只要条件允许，哲学家可以拿起左边或者右边的叉子，但在没有同时拿到左右叉子时不能进食。
假设面的数量没有限制，哲学家也能随便吃，不需要考虑吃不吃得下。
设计一个进餐规则（并行算法）使得每个哲学家都不会挨饿；也就是说，在没有人知道别人什么时候想吃东西或思考的情况下，每个哲学家都可以在吃饭和思考之间一直交替下去。

哲学家从 0 到 4 按 顺时针 编号。请实现函数 void wantsToEat(philosopher, pickLeftFork, pickRightFork, eat, putLeftFork, putRightFork)：
philosopher 哲学家的编号。
pickLeftFork 和 pickRightFork 表示拿起左边或右边的叉子。
eat 表示吃面。
putLeftFork 和 putRightFork 表示放下左边或右边的叉子。
由于哲学家不是在吃面就是在想着啥时候吃面，所以思考这个方法没有对应的回调。
给你 5 个线程，每个都代表一个哲学家，请你使用类的同一个对象来模拟这个过程。在最后一次调用结束之前，可能会为同一个哲学家多次调用该函数。
示例：
输入：n = 1
输出：[[4,2,1],[4,1,1],[0,1,1],[2,2,1],[2,1,1],[2,0,3],[2,1,2],[2,2,2],[4,0,3],[4,1,2],[0,2,1],[4,2,2],[3,2,1],[3,1,1],[0,0,3],[0,1,2],[0,2,2],[1,2,1],[1,1,1],[3,0,3],[3,1,2],[3,2,2],[1,0,3],[1,1,2],[1,2,2]]
解释:
n 表示每个哲学家需要进餐的次数。
输出数组描述了叉子的控制和进餐的调用，它的格式如下：
output[i] = [a, b, c] (3个整数)

• a 哲学家编号。
• b 指定叉子：{1 : 左边, 2 : 右边}.
• c 指定行为：{1 : 拿起, 2 : 放下, 3 : 吃面}。
  如 [4,2,1] 表示 4 号哲学家拿起了右边的叉子。

A：
引用：@̶.̶G̶F̶u̶＇̶ 、̶ ̶|
这个题目是防止死锁，每个哲学家都拿起左手或右手，导致死锁
1.第一种方法是设置一个信号量，当前哲学家会同时拿起左手和右手的叉子直至吃完。即有3 个人中，2 个人各自持有 2 个叉子，1 个人持有 1 个叉子，共计 5 个叉子。
用Semaphore去实现上述的限制：Semaphore eatLimit = new Semaphore(4);
一共有5个叉子，视为5个ReentrantLock，并将它们全放入1个数组中。
设置编码：

代码：

class DiningPhilosophers {
    //1个Fork视为1个ReentrantLock，5个叉子即5个ReentrantLock，将其都放入数组中
    private ReentrantLock[] locks = {new ReentrantLock(), new ReentrantLock(), new ReentrantLock(), new ReentrantLock(), new ReentrantLock()};
    //限制 最多只有4个哲学家去持有叉子
    private Semaphore eatLimit = new Semaphore(4);

    public DiningPhilosophers() {

    }

    // call the run() method of any runnable to execute its code
    public void wantsToEat(int philosopher,
                           Runnable pickLeftFork,
                           Runnable pickRightFork,
                           Runnable eat,
                           Runnable putLeftFork,
                           Runnable putRightFork) throws InterruptedException {
        int leftFork = (philosopher + 1) % 5;//左边的叉子 的编号
        int rightFork = philosopher;//右边的叉子 的编号

        eatLimit.acquire();//限制人数减一

        locks[leftFork].lock();
        locks[rightFork].lock();

        pickLeftFork.run();
        pickRightFork.run();

        eat.run();

        putLeftFork.run();
        putRightFork.run();

        locks[leftFork].unlock();
        locks[rightFork].unlock();

        eatLimit.release();
    }
}

2.设置 1 个临界区以实现 1 个哲学家 “同时”拿起左右 2 把叉子的效果。即进入临界区之后，保证成功获取到左右 2 把叉子 并 执行相关代码后，才退出临界区。
与上一种的差别是“允许1个哲学家用餐”。方法2是在成功拿起左右叉子之后就退出临界区，而“只让1个哲学家就餐”是在拿起左右叉子 + 吃意面 + 放下左右叉子 一套流程走完之后才退出临界区。
前者的情况可大概分为2种，举具体例子说明(可参照上面给出的图片)：

• 1号哲学家拿起左右叉子(1号叉子 + 2号叉子)后就退出临界区，此时4号哲学家成功挤进临界区，他也成功拿起了左右叉子(0号叉子和4号叉子)，然后就退出临界区。
• 1号哲学家拿起左右叉子(1号叉子 + 2号叉子)后就退出临界区，此时2号哲学家成功挤进临界区，他需要拿起2号叉子和3号叉子，但2号叉子有一定的概率还被1号哲学家持有(1号哲学家意面还没吃完)，因此2号哲学家进入临界区后还需要等待2号叉子。至于3号叉子，根本没其他人跟2号哲学家争夺，因此可以将该种情况视为“2号哲学家只拿起了1只叉子，在等待另1只叉子”的情况。

总之，第1种情况即先后进入临界区的2位哲学家的左右叉子不存在竞争情况，因此先后进入临界区的2位哲学家进入临界区后都不用等待叉子，直接就餐。此时可视为2个哲学家在同时就餐(当然前1个哲学家有可能已经吃完了，但姑且当作是2个人同时就餐)。
第2种情况即先后进入临界区的2位哲学家的左右叉子存在竞争情况(说明这2位哲学家的编号相邻)，因此后进入临界区的哲学家还需要等待1只叉子，才能就餐。此时可视为只有1个哲学家在就餐。
至于“只允许1个哲学家就餐”的代码，很好理解，每次严格地只让1个哲学家就餐，由于过于严格，以至于都不需要将叉子视为ReentrantLock。
方法2有一定的概率是“并行”，“只允许1个哲学家就餐”是严格的“串行”。

代码：

class DiningPhilosophers {
    //1个Fork视为1个ReentrantLock，5个叉子即5个ReentrantLock，将其都放入数组中
	private ReentrantLock[] lockList = {new ReentrantLock(),
		new ReentrantLock(),
		new ReentrantLock(),
		new ReentrantLock(),
		new ReentrantLock()};
    
    //让 1个哲学家可以 “同时”拿起2个叉子(搞个临界区)
	private ReentrantLock pickBothForks = new ReentrantLock();

	public DiningPhilosophers() {

	}

	// call the run() method of any runnable to execute its code
	public void wantsToEat(int philosopher,
		Runnable pickLeftFork,
		Runnable pickRightFork,
		Runnable eat,
		Runnable putLeftFork,
		Runnable putRightFork) throws InterruptedException {
        
		int leftFork = (philosopher + 1) % 5;	//左边的叉子 的编号
		int rightFork = philosopher;	//右边的叉子 的编号

		pickBothForks.lock();	//进入临界区

		lockList[leftFork].lock();	//拿起左边的叉子
		lockList[rightFork].lock();	//拿起右边的叉子

		pickLeftFork.run();	//拿起左边的叉子 的具体执行
		pickRightFork.run();	//拿起右边的叉子 的具体执行
        
		pickBothForks.unlock();	//退出临界区

		eat.run();	//吃意大利面 的具体执行

		putLeftFork.run();	//放下左边的叉子 的具体执行
		putRightFork.run();	//放下右边的叉子 的具体执行

		lockList[leftFork].unlock();	//放下左边的叉子
		lockList[rightFork].unlock();	//放下右边的叉子
	}
}

3.前面说过，该题的本质是考察 如何避免死锁。
而当5个哲学家都左手持有其左边的叉子 或 当5个哲学家都右手持有其右边的叉子时，会发生死锁。
故只需设计1个避免发生上述情况发生的策略即可。
即可以让一部分哲学家优先去获取其左边的叉子，再去获取其右边的叉子；再让剩余哲学家优先去获取其右边的叉子，再去获取其左边的叉子。
代码：

class DiningPhilosophers {
	//1个Fork视为1个ReentrantLock，5个叉子即5个ReentrantLock，将其都放入数组中
	private ReentrantLock[] lockList = {new ReentrantLock(),
		new ReentrantLock(),
		new ReentrantLock(),
		new ReentrantLock(),
		new ReentrantLock()};

	public DiningPhilosophers() {

	}

	// call the run() method of any runnable to execute its code
	public void wantsToEat(int philosopher,
		Runnable pickLeftFork,
		Runnable pickRightFork,
		Runnable eat,
		Runnable putLeftFork,
		Runnable putRightFork) throws InterruptedException {

		int leftFork = (philosopher + 1) % 5;    //左边的叉子 的编号
		int rightFork = philosopher;    //右边的叉子 的编号

        //编号为偶数的哲学家，优先拿起左边的叉子，再拿起右边的叉子
		if (philosopher % 2 == 0) {
			lockList[leftFork].lock();    //拿起左边的叉子
			lockList[rightFork].lock();    //拿起右边的叉子
		}
        //编号为奇数的哲学家，优先拿起右边的叉子，再拿起左边的叉子
		else {
			lockList[rightFork].lock();    //拿起右边的叉子
			lockList[leftFork].lock();    //拿起左边的叉子
		}

		pickLeftFork.run();    //拿起左边的叉子 的具体执行
		pickRightFork.run();    //拿起右边的叉子 的具体执行

		eat.run();    //吃意大利面 的具体执行

		putLeftFork.run();    //放下左边的叉子 的具体执行
		putRightFork.run();    //放下右边的叉子 的具体执行

		lockList[leftFork].unlock();    //放下左边的叉子
		lockList[rightFork].unlock();    //放下右边的叉子
	}
}

改进：改进代码看3种解法（互斥锁或volatile）
1.ReentrantLock和synchronize关键字都是使用互斥量的重量级锁，而volatile关键字相较于它们就比较“轻量”。
因此把ReentrantLock数组改为使用volatile修饰的boolean数组。
PS: volatile要和原子操作搭配使用才能保证同步。
而对volatile变量赋 常量值 可看为是原子操作。

看着后面这种解法更清晰：
每个人都可以尝试去吃东西，吃东西前尝试去拿左边的叉子和右边的叉子，这样就可以想到使用信号量Semaphore的tryAcquire方法。
这里竞争的资源是叉子，所以定义代表5个叉子的信号量即可。
代码：

class DiningPhilosophers {
    int num = 5;
    //五个叉子的信号量
    private Semaphore[] semaphores = new Semaphore[5];

    public DiningPhilosophers() {
        for (int i = 0; i < num; i++) {
            //每只叉子只有1个
            semaphores[i] = new Semaphore(1);
        }

    }

    // call the run() method of any runnable to execute its code
    public void wantsToEat(int philosopher,
                           Runnable pickLeftFork,
                           Runnable pickRightFork,
                           Runnable eat,
                           Runnable putLeftFork,
                           Runnable putRightFork) throws InterruptedException {
        //左边叉子的位置
        int left = philosopher;
        //右边叉子的位置
        int right = (philosopher + 1) % num;
        while (true) {
            if (semaphores[left].tryAcquire()) {
                //先尝试获取左边叉子，如果成功再尝试获取右边叉子
                if (semaphores[right].tryAcquire()) {
                    //两个叉子都得到了，进餐
                    pickLeftFork.run();
                    pickRightFork.run();
                    eat.run();
                    putLeftFork.run();
                    //释放左边叉子
                    semaphores[left].release();
                    putRightFork.run();
                    //释放右边边叉子
                    semaphores[right].release();

                    //吃完了，就跳出循环
                    break;
                } else {
                    //如果拿到了左边的叉子，但没拿到右边的叉子： 就释放左边叉子
                    semaphores[left].release();
                    //让出cpu等一会
                    Thread.yield();
                }
            } else {
                //连左边叉子都没拿到，就让出cpu等会吧
                Thread.yield();
            }
        }

    }

}