经典线程同步问题：哲学家就餐

huiyugan

发布于 2022-11-9 11:39

浏览

0收藏

场景

有五位沉默的哲学家围坐在一张圆桌旁，他们一生都在吃东西和思考。

有五只筷子供他们使用，哲学家需要双手拿到一双筷子之后才能吃饭；吃完后会将筷子放下继续思考。

那么现在有一个问题，我们需要想出一种方案，如何保证哲学家们可以交替吃饭和思考，而不会被饿死。

经典线程同步问题：哲学家就餐-鸿蒙开发者社区

哲学家就餐问题

上面这个问题是由Dijkstra提出的一个经典的线程同步问题。

解决方案

我们在开始想如何解决问题之前，可以先将这个场景通过代码还原，在程序中进行建模。

每一只筷子可以看做是一个资源数据，都可以被它两边的哲学家尝试去获取，并且同一时间只能由其中一人持有，这可以通过我们JUC包中的信号量Semaphore来表示。

然后，每个哲学家可以看做是一个线程，每个线程中的run方法内容都是先进行思考，然后试图获取左右两边的筷子吃饭，吃完饭后继续思考。

通过上面的分析，我们的代码实现如下：

/**
 * @author 小黑说Java
 * @ClassName DiningPhilosophers
 * @Description 哲学家就餐问题
 * @date 2022/2/6
 **/
@Slf4j
public class DiningPhilosophers implements Runnable {

    private final int id;

    public DiningPhilosophers(int id){
        this.id = id;
    }

    private static final Random random = new Random(System.currentTimeMillis());

    private static final Semaphore[] forks = new Semaphore[5];

    // 初始化信号量,每个信号量为1，代表1只筷子
    static {
        forks[0] = new Semaphore(1);
        forks[1] = new Semaphore(1);
        forks[2] = new Semaphore(1);
        forks[3] = new Semaphore(1);
        forks[4] = new Semaphore(1);
    }

    @Override
    public void run(){
        try {
            while (true) {
                think();
                eat(id);
            }
        } catch (InterruptedException e) {
            log.error("异常中断", e);
        }
    }

    /**
     * 哲学家思考随机时间
     */
    private void think() throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(random.nextInt(100));
    }

    private void eat(int id){
        // TODO
    }

}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.

接下来，我们思考一下，如何实现哲学家吃饭的逻辑。

当一个哲学家需要吃饭时，他要拿起左右两边的筷子。所以：

哲学家 A(0) 需要筷子0 和 4
哲学家 B(1) 需要筷子 1 和 0
哲学家 C(2) 需要筷子 2 和 1
哲学家 D(3) 需要筷子 3 和 2
哲学家 E(4) 需要筷子 4 和 3

所以每个哲学家线程都应该有个编号，所以我在DiningPhilosophers中定义了属性id表示哲学家的编号。

在吃饭方法中，需要根据id来决定获取哪只筷子。

左手边的筷子可以用fork[id]表示；

右手边的筷子用fork[(id+4)%5]表示。

那么我们的eat方法的实现如下：

private void eat(int id) throws InterruptedException {
    // 先拿左边的筷子
    forks[id].acquire();

    // 然后拿右边的筷子
    forks[(id + 4) % 5].acquire();

    // 吃一口饭
    log.info("哲学家{}正在吃饭~", id);

    // 依次放下左边的筷子和右边的筷子
    forks[id].release();
    forks[(id + 4) % 5].release();
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

我们接着来测试我们的完整代码。

/**
 * @author 小黑说Java
 * @ClassName DiningPhilosophers
 * @Description 哲学家就餐问题
 * @date 2022/2/6
 **/
@Slf4j
public class DiningPhilosophers implements Runnable {

    private final int id;

    public DiningPhilosophers(int id){
        this.id = id;
    }

    private static final Random random = new Random(System.currentTimeMillis());

    private static final Semaphore[] forks = new Semaphore[5];

    // 初始化信号量,每个信号量为1，代表1只筷子
    static {
        forks[0] = new Semaphore(1);
        forks[1] = new Semaphore(1);
        forks[2] = new Semaphore(1);
        forks[3] = new Semaphore(1);
        forks[4] = new Semaphore(1);
    }

    @Override
    public void run(){
        try {
            while (true) {
                think();
                eat(id);
            }
        } catch (InterruptedException e) {
            log.error("异常中断", e);
        }
    }

    /**
     * 哲学家思考随机时间
     */
    private void think() throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(random.nextInt(100));
    }

    private void eat(int id) throws InterruptedException {
        // 先拿左边的筷子
        forks[id].acquire();

        // 然后拿右边的筷子
        forks[(id + 4) % 5].acquire();

        // 吃一口饭
        log.info("哲学家{}正在吃饭~", id);

        // 依次放下左边的筷子和右边的筷子
        forks[id].release();
        forks[(id + 4) % 5].release();
    }

    public static void main(String[] args){
        for (int i = 0; i < 5; i++) {
            new Thread(new DiningPhilosophers(i)).start();
        }
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.

运行上面的代码后，会发现程序在运行一段时间后会进入死锁状态。

这种情况是因为，在某一时刻，所有的哲学家都获取到了左手边的筷子，而无法获取到右手边的筷子，导致没有人可以到东西，陷入僵局。

该如何避免出现这种死锁问题呢？

方法一：限制吃饭的哲学家人数

很简单的一种方法，就是在一个时间点，只能有最多4个哲学家开始吃饭。4个哲学家分5只筷子，则永远不会发生死锁。

要实现这种方法，我们可以再定义一个许可数为4的信号量Semaphore，表示剩余可以吃饭的哲学家名额。

代码实现如下：

/**
 * @author 小黑说Java
 * @ClassName DiningPhilosophers
 * @Description 哲学家就餐问题
 * @date 2022/2/6
 **/
@Slf4j
public class DiningPhilosophers implements Runnable {

    private final int id;

    public DiningPhilosophers(int id){
        this.id = id;
    }

    private static final Random random = new Random(System.currentTimeMillis());

    private static final Semaphore[] forks = new Semaphore[5];

    private static final Semaphore maxDiners = new Semaphore(4);


    // 初始化信号量,每个信号量为1，代表1只筷子
    static {
        forks[0] = new Semaphore(1);
        forks[1] = new Semaphore(1);
        forks[2] = new Semaphore(1);
        forks[3] = new Semaphore(1);
        forks[4] = new Semaphore(1);
    }

    @Override
    public void run(){
        try {
            while (true) {
                think();
                eat(id);
            }
        } catch (InterruptedException e) {
            log.error("异常中断", e);
        }
    }

    /**
     * 哲学家思考随机时间
     */
    private void think() throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(random.nextInt(100));
    }

    private void eat(int id) throws InterruptedException {
        // 先获得吃饭名额
        maxDiners.acquire();

        // 先拿左边的筷子
        forks[id].acquire();

        // 然后拿右边的筷子
        forks[(id + 4) % 5].acquire();

        // 吃一口饭
        log.info("哲学家{}正在吃饭~", id);

        // 依次放下左边的筷子和右边的筷子
        forks[id].release();
        forks[(id + 4) % 5].release();

        // 吃完之后归还吃饭名额
        maxDiners.release();
    }

    public static void main(String[] args){
        for (int i = 0; i < 5; i++) {
            new Thread(new DiningPhilosophers(i)).start();
        }
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.

方法二：找到一个左撇子哲学家

这种方法是让其中一个哲学家和其他哲学家拿筷子的顺序和其他哲学家不一样。

比如其他人都是先拿右手边再拿左手边，而这个左撇子哲学家则先拿左手边再拿右手边。

而哪一位哲学家被选为左撇子并不重要，因为桌子是圆的，所以我们就选择0号哲学家为左撇子。

代码实现如下：

/**
 * @author 小黑说Java
 * @ClassName DiningPhilosophers
 * @Description 哲学家就餐问题
 * @date 2022/2/6
 **/
@Slf4j
public class DiningPhilosophers implements Runnable {

    private final int id;

    public DiningPhilosophers(int id){
        this.id = id;
    }

    private static final Random random = new Random(System.currentTimeMillis());

    private static final Semaphore[] forks = new Semaphore[5];


    // 初始化信号量,每个信号量为1，代表1只筷子
    static {
        forks[0] = new Semaphore(1);
        forks[1] = new Semaphore(1);
        forks[2] = new Semaphore(1);
        forks[3] = new Semaphore(1);
        forks[4] = new Semaphore(1);
    }

    @Override
    public void run(){
        try {
            while (true) {
                think();
                eat(id);
            }
        } catch (InterruptedException e) {
            log.error("异常中断", e);
        }
    }

    /**
     * 哲学家思考随机时间
     */
    private void think() throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(random.nextInt(100));
    }

    private void eat(int id) throws InterruptedException {
        if (id == 0) {
            hanleLeftFirst(id);
        } else {
            hanldRightFirst(id);
        }
        // 吃一口饭
        log.info("哲学家{}正在吃饭~", id);
        forks[id].release();
        forks[(id + 4) % 5].release();
    }

    private void hanleLeftFirst(int id) throws InterruptedException {
        forks[id].acquire();
        forks[(id + 4) % 5].acquire();
    }

    private void hanldRightFirst(int id) throws InterruptedException {
        forks[(id + 4) % 5].acquire();
        forks[id].acquire();
    }

    public static void main(String[] args){
        for (int i = 0; i < 5; i++) {
            new Thread(new DiningPhilosophers(i)).start();
        }
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.

小结

哲学家就餐问题是用来演示线程同步的一个经典问题，除了上述文中提到的两种方式可以避免哲学家陷入死锁的僵局外，你是否还有其他更好的方法呢？

如果本文对你有所帮助，可以给小黑点个赞鼓励下。

我是小黑，一名在互联网“苟且”的程序员
流水不争先，贵在滔滔不绝

分类

其他

标签

线程同步

已于2022-11-9 11:39:14修改

51CTO

51CTO博客

51CTO学堂

经典线程同步问题：哲学家就餐

场景

解决方案

方法一：限制吃饭的哲学家人数

方法二：找到一个左撇子哲学家

小结

目录

订阅鸿蒙技术特刊，精选内容抢先看

51CTO

51CTO博客

51CTO学堂

经典线程同步问题：哲学家就餐

场景​

解决方案​

方法一：限制吃饭的哲学家人数

方法二：找到一个左撇子哲学家

小结​

目录

订阅鸿蒙技术特刊，精选内容抢先看

场景

解决方案

小结