脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java线程同步

Java线程同步问题--哲学家就餐

 更新时间：2022年02月14日 14:27:11   作者：小黑说Java  
这篇文章主要介绍了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线程同步内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • java利用DFA算法实现敏感词过滤功能

    java利用DFA算法实现敏感词过滤功能

    在最近的开发中遇到了敏感词过滤，便去网上查阅了很多敏感词过滤的资料，在这里也和大家分享一下自己的理解。下面这篇文章主要给大家介绍了关于java利用DFA算法实现敏感词过滤功能的相关资料，需要的朋友可以参考借鉴，下面来一起看看吧。
    2017-06-06
  • MyBatis Plus逻辑删除和分页插件使用详解

    MyBatis Plus逻辑删除和分页插件使用详解

    这篇文章主要介绍了MyBatis Plus之逻辑删除和分页插件使用,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2020-12-12
  • 一文掌握Springboot集成RabbitMQ的方法

    一文掌握Springboot集成RabbitMQ的方法

    RabbitMQ是开源的消息队列服务器,实现了AMQP高级消息队列协议标准,AMQP 是一种应用层协议,为面向消息的中间件设计,基于此协议的客户端与消息中间件可传递消息,并不受产品、开发语言等条件的限制,这篇文章主要介绍了Springboot集成RabbitMQ的过程,需要的朋友可以参考下
    2024-04-04
  • spring事务异常回滚实例解析

    spring事务异常回滚实例解析

    这篇文章主要介绍了spring事务异常回滚实例解析，具有一定借鉴价值,需要的朋友可以参考下
    2018-01-01
  • 一文详解Java中的注解(Annotation)

    一文详解Java中的注解(Annotation)

    在Java中注解(Annotation)引入始于Java5,用来描述Java代码的元信息,通常情况下注解不会直接影响代码的执行,尽管有些注解可以用来做到影响代码执行,这篇文章主要给大家介绍了关于Java中注解(Annotation)的相关资料,需要的朋友可以参考下
    2024-03-03
  • Java实现LRU缓存算法的参考示例

    Java实现LRU缓存算法的参考示例

    这篇文章主要介绍了JAVA实现LRU缓存算法的参考示例，帮助大家根据需求实现算法，对大家的学习或工作有一定的参考价值,需要的朋友可以参考下
    2023-05-05
  • java 实现图片像素质量压缩与图片长宽缩放

    java 实现图片像素质量压缩与图片长宽缩放

    这篇文章主要介绍了java 实现图片像素质量压缩与图片长宽缩放，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2021-11-11
  • SpringBoot开发之整合Mybatis详解

    SpringBoot开发之整合Mybatis详解

    这篇文章主要介绍了SpringBoot开发之整合Mybatis详解,MyBatis是一个半自动的ORM框架,它允许我们通过编写SQL语句来操作数据库,使用MyBatis,我们可以通过定义映射文件(XML文件)或使用注解的方式将Java对象与数据库表进行映射,需要的朋友可以参考下
    2023-09-09
  • Java自定义实现链队列详解

    Java自定义实现链队列详解

    这篇文章主要为大家详细介绍了Java自定义实现链队列的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2017-12-12
  • Spring中循环依赖的解决方法详析

    Spring中循环依赖的解决方法详析

    这篇文章主要给大家介绍了关于Spring中循环依赖的解决方法，文中通过示例代码介绍的非常详细，对大家学习或者使用spring具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
    2019-08-08

最新评论