Java线程同步问题实例分析

这篇文章主要讲解了“Java线程同步问题实例分析”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“Java线程同步问题实例分析”吧！

1.场景

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

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

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

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

2.解决方案

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

每一只筷子可以看做是一个资源数据，都可以被它两边的哲学家尝试去获取，并且同一时间只能由其中一人持有，这可以通过我们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
    }

}

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

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

所以：

• 哲学家 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();
}

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

/**
 * @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();
        }
    }
}

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

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

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

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

很简单的一种方法，就是在一个时间点，只能有最多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();
        }
    }
}

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

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

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

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

代码实现如下：

/**
 * @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();
        }
    }
}

感谢各位的阅读，以上就是“Java线程同步问题实例分析”的内容了，经过本文的学习后，相信大家对Java线程同步问题实例分析这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是亿速云，小编将为大家推送更多相关知识点的文章，欢迎关注！