【多线程学习九】通过ReentrantLock解决哲学家就餐问题

最新推荐文章于 2026-03-02 05:58:15 发布
原创 最新推荐文章于 2026-03-02 05:58:15 发布 · 383 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#学习 #java #开发语言
本文探讨了五个哲学家就餐问题，通过Java ReentrantLock实现避免死锁的解决方案。介绍可重入锁、可中断、超时和条件变量在解决哲学家困境中的应用，展示了如何使用tryLock方法和条件变量来确保并发安全。

哲学家就餐问题

在这里插入图片描述

五个哲学家，只做两件事，思考和吃饭。

吃饭要用到两根筷子，每个哲学家左手边和右手边各有一根筷子，而桌上只有五根，当筷子被旁边的人拿着，自己就只能进入等待

筷子类

class Chopstick {
    String name;
    
    public Chopstick(String name) {
        this.name = name;
    }
    
    @Override
    public String toString() {
        return "筷子{" + name + '}';
    }
}

哲学家类

class Philosopher extends Thread {
    Chopstick left;
    Chopstick right;
    
    public Philosopher(String name, Chopstick left, Chopstick right) {
        super(name);
        this.left = left;
        this.right = right;
    }
    
    private void eat() {
        log.debug("eating...");
        Sleeper.sleep(1);
    }
    
    @Override
    public void run() {
        while (true) {
            // 获得左手筷子
            synchronized (left) {
                // 获得右手筷子
                synchronized (right) {
                    // 吃饭
                    eat();
                }
                // 放下右手筷子
            }
            // 放下左手筷子
        }
    }
    
}

就餐（执行）

Chopstick c1 = new Chopstick("1");
Chopstick c2 = new Chopstick("2");
Chopstick c3 = new Chopstick("3");
Chopstick c4 = new Chopstick("4");
Chopstick c5 = new Chopstick("5");

new Philosopher("苏格拉底", c1, c2).start();
new Philosopher("柏拉图", c2, c3).start();
new Philosopher("亚里士多德", c3, c4).start();
new Philosopher("赫拉克利特", c4, c5).start();
new Philosopher("阿基米德", c5, c1).start();

执行后，用jconsole检测死锁发现五位哲学家都进入了死锁状态

ReentrantLock

可重入锁，顾名思义，支持可重入

  • 可中断
  • 可设置超时时间
  • 可设置为公平锁（先进先出，处理饥饿，但是一般不使用）
  • 支持多个条件变量（Condition）

基本语法
在这里插入图片描述

  • 可重入指线程1首次获得了锁A，因为线程1是锁A的拥有者，所有有权利再次获取这把锁
  • 不可重入锁，第二次获得锁时，自己也会被锁挡住
@Slf4j
public class Reentrant {
    static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        method1();
    }

    public static void method1(){
//            获取锁
            lock.lock();
            try {
//              临界区
                log.info("execute method1");
                method2();
            }finally {
//                释放锁
                lock.unlock();
            }
    }

    public static void method2(){
//            获取锁
        lock.lock();
        try {
//              临界区
            log.info("execute method2");
        }finally {
//                释放锁
            lock.unlock();
        }
    }
}

在这里插入图片描述

可打断

lock.lockInterruptibly()，可以防止线程一直等待锁

@Slf4j
public class Reentrant {
    static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
       Thread t1 = new Thread(()->{
          log.info("start...");
          try {
//              判断锁是否被打断，打断了抛出异常
//              没有打断则get lock...执行完后释放锁
              lock.lockInterruptibly();
          }catch (InterruptedException e){
              e.printStackTrace();
              log.info("waiting is interrupt...");
              return;
          }

          try {
              log.info("get lock....");
          }finally {
              // 释放锁
              lock.unlock();
          }
       },"t1");
       lock.lock();
       log.info("get lock ....");
       t1.start();
       try {
           Sleepy.sleep(1000);
           t1.interrupt();
           log.info("interrupt execute");
       }finally {
           lock.unlock();
       }
    }
}

主线程获取锁后，执行t1线程，此时t1线程被打断，抛出异常后跳出循环

在这里插入图片描述

如果是不可中断模式，即使使用了interrupt也不会让等待中断

@Slf4j
public class Reentrant {
    static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
       Thread t1 = new Thread(()->{
          log.info("start...");
          lock.lock();
          try {
              log.info("get lock....");
          }finally {
              // 释放锁
              lock.unlock();
          }
       },"t1");
       lock.lock();
       log.info("get lock ....");
       t1.start();
       try {
           Sleepy.sleep(1000);
           t1.interrupt();
           log.info("interrupt execute");
       }finally {
           lock.unlock();
       }
    }
}

t1不会因为interrupt而获取不到锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lz4LaEAE-1655570755988)(D:\Note\面试学习笔记.assets\image-20220619001322326.png)]

锁超时
立刻失败
	static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            log.info("start.....");
//            获取锁失败时立刻失败
            if(!lock.tryLock()){
                log.info("fail to get the lock.....");
                return;
            }
            try {
                log.info("get lock...");
            }finally {
                lock.unlock();
            }
        },"t1");

        lock.lock();
        t1.start();
        try {
            Sleepy.sleep(1000);
        }finally {
            lock.unlock();
        }
    }

在这里插入图片描述

超时失败

t1在1s后，因为主线程释放了锁，所以获取锁成功

 public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            log.info("start.....");
//            获取锁失败时等待1秒
            try {
                if(!lock.tryLock(1, TimeUnit.SECONDS)){
                    log.info("fail to get the lock.....");
                    return;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                log.info("get lock...");
            }finally {
                lock.unlock();
            }
        },"t1");

        lock.lock();
        t1.start();
        try {
            Sleepy.sleep(1000);
        }finally {
            lock.unlock();
        }
    }

在这里插入图片描述

使用tryLock解决哲学家问题

class Chopstick extends ReentrantLock {
    String name;
    
    public Chopstick(String name) {
        this.name = name;
    }
    
    @Override
    public String toString() {
        return "筷子{" + name + '}';
    }
}

class Philosopher extends Thread {
    
    Chopstick left;
    Chopstick right;
    
    public Philosopher(String name, Chopstick left, Chopstick right) {
        super(name);
        this.left = left;
        this.right = right;
    }
    
    @Override
    public void run() {
        while (true) {
            // 尝试获得左手筷子
            if (left.tryLock()) {
                try {
                    // 尝试获得右手筷子
                    if (right.tryLock()) {
                        try {
                            eat();
                        } finally {
                            right.unlock();
                        }
                    }
                } finally {
                    left.unlock();
                }
            }
        }
    }
    
    private void eat() {
        log.debug("eating...");
        Sleeper.sleep(1);
    }
    
}
条件变量

Synchronized也有条件变量，在monitor中的waitSet，当条件不满足时进入waitSet等待

ReentrantLock的条件变量可以有多个

使用要点

  • await前需要获取锁
  • await执行后会释放锁，进入条件变量对象（conditionObject）等待
  • await的线程==被唤醒（打断/超时）==去重新竞争lock锁
  • 竞争lock锁成功后，从await后继续执行

通过公车和汽车两个条件，创建对应的条件变量

​ --》当还没有车启动时，进入等待状态，此时获得了锁，在此期间一直等待车子发动

​ --》当车发动后，条件变量收到通知，开始上车操作

@Slf4j
public class MutilCondition {
    static ReentrantLock lock = new ReentrantLock();
    static Condition waitCar = lock.newCondition();
    static Condition waitBus = lock.newCondition();
    static volatile boolean hasCar = false;
    static volatile boolean hasBus = false;

    public static void main(String[] args) {
        new Thread(()->{
            try {
                lock.lock();
                while(!hasCar){
                    try {
                        waitCar.await();
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
                log.info("car coming and get...");
            }finally {
//                等到汽车后释放锁
                lock.unlock();
            }
        }).start();


        new Thread(()->{
            try {
                lock.lock();
                while (!hasBus){
                    try {
                        waitBus.await();
                    }catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.info("bus coming and get...");
            }finally {
                lock.unlock();
            }
        }).start();

        Sleepy.sleep(1000);
        startCar();
        Sleepy.sleep(1000);
        startBus();

    }


    private static void startCar(){
        lock.lock();
        try {
            log.info("car is starting...");
            hasCar = true;
//            等汽车的条件变量收到通知
            waitCar.signal();
        }finally {
            lock.unlock();
        }
    }

    private static void startBus(){
        lock.lock();
        try {
            log.info("bus is starting...");
            hasBus = true;
//            等公交的条件变量收到通知
            waitBus.signal();
        }finally {
            lock.unlock();
        }
    }
}

在这里插入图片描述

哲学家就餐问题（死锁）
Qynwang的博客
06-03 1119
本文主要讲述死锁的一个经典案例—哲学家就餐问题，并对该问题进行修复。
基于ReentrantLock发生死锁的解决方案
jijianshuai的专栏
07-20 4900
概念死锁是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。 由于资源占用是互斥的，当某个进程提出申请资源后，使得有关进程在无外力协助下，永远分配不到必需的资源而无法继续运行，这就产生了一种特殊现象：死锁。”活锁(英文 livelock)指事物1可以使用资源，但它
并发编程学习（八）：ReentrantLock特性、哲学家吃饭问题
weixin_40482816的博客
01-30 1063
ReentrantLock 是java.util.concurrent.locks包下的类。相对于synchronized,它具备如下特性：可中断。可以设置超时时间。可以设置公平锁。支持多个条件变量。即可以有个多个waitset等待队列。与synchronized都支持可重入。可冲入是指 同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁。如果是不可冲入锁，那么第二次获取锁时，自己会被锁挡住。
java 多线程2
上千主上-贝库塔
09-02 519
java 多线程 进程
Java线程-Lock锁-线程间通信-线程池
weixin_43317099的博客
04-03 739
文章目录1.线程的Lock锁的使用2.死锁问题3.线程间通信--等待唤醒机制1.最基本的版本，只有一个数据2.改进版本，给出了不同的数据，并加入了同步机制3-2.等待唤醒机制3.等待唤醒机制改进该程序，让数据能够实现依次的出现4.等待唤醒机制的代码优化。把数据及操作都写在了资源类中3-3.线程的状态转换4.线程组5.线程池5-1.线程的第三种方式：实现Callable接口5-2.线程求和案例6.匿...
哲学家就餐问题及解决方法
知识不加糖的分享圈
04-14 9227
问题描述 哲学家就餐问题(Dining philosophers problem)是在计算机科学中的一个经典问题，用来演示在并发计算中多线程同步时产生的问题。 在1971年，著名的计算机科学家艾兹格·迪科斯彻提出了一个同步问题，即假设有五台计算机都试图访问五份共享的磁带驱动器。稍后，这个问题被托尼·霍尔重新表述为哲学家就餐问题。这个问题可以用来解释死锁和资源耗尽。 哲学家就餐问题可以这样表述，假设...
ReentrantLock实战：如何用可中断锁优雅解决死锁问题（附哲学家就餐案例）
q5r6s7的博客
02-11 907
本文深入解析ReentrantLock的可中断锁特性及其在解决死锁问题中的应用，通过哲学家就餐案例展示如何优雅处理线程同步。文章详细介绍了lockInterruptibly()方法、锁超时机制以及公平锁与非公平锁的对比，为Java并发编程提供实用指南。
哲学家就餐不用愁：ReentrantLock的tryLock()如何轻松解决死锁难题
最新发布
java5的博客
03-02 1003
本文以经典的哲学家就餐问题为引，深入剖析了Java多线程编程中的死锁难题。重点介绍了ReentrantLock的tryLock()方法，特别是其带超时参数的版本，如何通过“尝试获取、超时退让”的策略，主动破坏死锁的必要条件，从而优雅地解决资源竞争导致的僵局。这是一种从被动阻塞到主动试探的并发设计哲学转变。
java多线程（并发）夯实之路- ReentrantLock深入浅出（解决哲学家问题）
qq_61282807的博客
01-11 999
但是顺序加锁容易导致饥饿问题，如哲学家就餐问题会有死锁产生，用顺序加锁解决死锁问题后，会出现饥饿问题（一些哲学家总是优先抢到锁，一直进餐，导致其他哲学家一直不能进餐）如果一个线程需要同时获得多把锁，就容易发生死锁 t1线程获得了A对象的锁，接下来想获得B对象的锁 t2线程获得了B对象的锁，接下来想获得A对象的锁。方法前需要先获得锁，方法执行之后会释放锁，进入condtionObject等待，被唤醒（打断，超时）重新竞争锁，成功获得锁后继续执行。()方法尝试获取锁，获取到了返回真，否则返回假（不会等待）。
ReentrantLock解决死锁
weixin_43939924的博客
05-12 851
package com.example.demo.hmjuc.day12; import java.util.concurrent.locks.ReentrantLock; /** * @author zhangqi * @date 2022/5/12 12:14 */ public class IntLock implements Runnable { public static ReentrantLock lockl = new ReentrantLock(); public
哲学家进餐问题 C++实现
daydream13580130043的博客
02-26 1万+
哲学家进餐问题描述 假设有五位哲学家围坐在一张圆形餐桌旁，做以下两件事情之一：吃饭，或者思考。吃东西的时候，他们就停止思考，思考的时候也停止吃东西。餐桌中间有一大碗意大利面，每两个哲学家之间有一只餐叉。因为用一只餐叉很难吃到意大利面，所以假设哲学家必须用两只餐叉吃东西。他们只能使用自己左右手边的那两只餐叉。哲学家就餐问题有时也用米饭和筷子而不是意大利面和餐叉来描述，因为很明显，吃米饭必须用两根筷...
System V 信号量(三)之用信号量解决哲学家进餐问题
热门推荐
u014304293的专栏
05-26 2万+
一.哲学家就餐问题           5个哲学家，5个筷子。5个哲学家围坐在一张桌子上，筷子放在分别放在每个哲学家的两旁。如果所有哲学家在某个时刻同时拿起左边的筷子，那么右边的筷子就都被其他的哲学家拿了，造成大家都无法吃饭。但是大家都不想放下左边的筷子（规则是先拿起左边筷子在拿起右边的，吃完饭在放下左,再放下右），这就是死锁。 解决这个问题有个办法是在拿起筷子前先判断左右两个筷子是否
利用ReentrantLock解决死锁----以哲学家问题为例
adru的博客
02-04 571
每位哲学家需要两根筷子才能吃饭，而每根筷子只能被一位哲学家使用，这就导致了资源的互斥性。在吃饭时会拿起左右两边的筷子，并保持持有直到吃完饭。如果筷子不足，他们就会等待，在这个场景中，哲学家不会从其他哲学家手中抢夺筷子，只有当筷子可用时，他们才会拿起筷子。可能发生所有哲学家都拿着手中的一根筷子，同时等待另一根筷子的情况，这样就形成了一个环路，每个人都在等待其他人释放资源，导致所有人都无法继续进餐，即发生了死锁。运行结果： 发现代码不会继续执行 ，此时已经发生了死锁。1. 采用synchronized写法。
哲学家就餐问题-中断解决
12-20 205
哲学家就餐问题是计算机操作系统课程中一定会拿来作为死锁教材的经典案例。问题描述如下：哲学家吃饭问题：哲学家聚在一起吃饭，假定哲学家人数是五，这五个哲学家坐在一张圆桌上面，每个哲学家的左手旁边都放有一个叉子(fork)，那么，这围城一圈的五个哲学家有五个叉子。每个哲学家有三种状态，thinking(思考)，trying(尝试去拿叉子吃饭)，eating(已经拿起叉子，正在吃饭)。每次吃饭需...
哲学家用餐问题程序解决
JJ-Li的博客
10-10 554
哲学家用餐问题是经典的进程调度问题，多个哲学家围在圆桌吃饭，但是两人中间只有一个筷子，编程解决这个问题并且模拟测试
哲学家干饭问题（基于C++）
BinWang_的博客
12-10 1655
哲学家就餐问题的场景设定在一张圆桌旁，五位哲学家围坐在桌子周围。每位哲学家面前有一根筷子，哲学家们的主要活动是思考和用餐。为了能够用餐，哲学家必须同时拿起左右两根筷子。这个简单的场景却引发了复杂的同步问题，成为了多线程编程中的经典案例。信号量结构体用于实现同一时间只能有一个哲学家拿起筷子，防止对同一个筷子的竞争，筷子结构体用于保证一个筷子一次只能被一个哲学家使用。// 信号量结构体// 互斥信号量，用于保护信号量计数// 条件变量，用于线程同步int sem;// 信号量计数。
五个哲学家进餐问题-Linux C实现（完整代码）
m0_52857070的博客
05-27 5751
1、问题分析 五根筷子是资源，当哲学家拿到两支筷子，即左右手旁的筷子，哲学家才能吃饭。 当哲学家都拿到左手或右手的筷子后，资源都被占用，没有一个哲学家能拿到两个筷子进餐。哲学家都等待对方释放资源，这就造成了死锁。 死锁产生的条件有 （1） 互斥即资源不能共享，只能由一个进程占用 （2）占有且等待即当一个等待另外进程而阻塞时，资源不主动释放 （3）不可抢占即操作系统不能强行抢占被进程持有的资源 （3）循环等待即存在一个封闭的进程链，使得每一个进程都至少占有下个进程所需要的资源。 ...
哲学家进餐问题（linux下C/C++源码）
csdn96087的博客
12-02 8571
哲学家进餐问题（linux下C/C++源码） 题目描述： 题目自行百度吧。 思路： 5个哲学家相当于5的线程，5支筷子相当于5把mutex锁。 假如他们都拿左手边的筷子，这时就容易发生死锁，即谁都就不了餐（震荡行为）。 此时就需要其中一位哲学家放弃手中的资源。为了避免这种行为，我们使前四位哲学家都拿起左手的筷子，而第五位哲学家拿右手的筷子，即与第四位哲学家争夺资源，如果争夺成功，此时去拿左手筷子即...
tryLock解决哲学家用餐死锁问题
qq_36083992的博客
12-30 661
哲学家用餐问题
用C语言多线程描述哲学家,并行程序设计-哲学家就餐问题
weixin_42434656的博客
05-22 1375
并行程序设计第4次作业——哲学家就餐问题一、问题描述五个沉默的哲学家围坐在一个圆桌旁，桌上放着几碗意大利面。叉子被放置在每一对相邻的哲学家之间。每个哲学家必须交替地思考和进餐。然而，哲学家只能在有左右叉子的情况下才能吃意大利面。每个叉子只能被一个哲学家拿着，所以一个哲学家只能在没有被另一个哲学家使用的情况下使用它。当一位哲学家吃完饭后，他们需要把两把叉子放下，这样其他人就可以享用这些叉子了。哲学家...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值