基于ReentrantLock发生死锁的解决方案

最新推荐文章于 2024-03-03 23:05:46 发布
最新推荐文章于 2024-03-03 23:05:46 发布
阅读量4.4k 收藏 12
点赞数 2
分类专栏： 并发编程 文章标签： 死锁 重入锁 并发编程 Renntrant Lock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jijianshuai/article/details/75478585
版权

概念

死锁

是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。 由于资源占用是互斥的，当某个进程提出申请资源后，使得有关进程在无外力协助下，永远分配不到必需的资源而无法继续运行，这就产生了一种特殊现象：死锁。”

活锁(英文 livelock)

指事物1可以使用资源，但它让其他事物先使用资源；事物2可以使用资源，但它也让其他事物先使用资源，于是两者一直谦让，都无法使用资源。

避免活锁的简单方法是采用先来先服务的策略。当多个事务请求封锁同一数据对象时，封锁子系统按请求封锁的先后次序对事务排队，数据对象上的锁一旦释放就批准申请队列中第一个事务获得锁。

示例一

使用tryLock()方法来防止多线程死锁。

tryLock()方法：尝试获取一把锁，如果获取成功返回true，如果还拿不到锁，就返回false。

public class DeadLock1 {

    private static Lock lock1 = new ReentrantLock();
    private static Lock lock2 = new ReentrantLock();

    public static void deathLock() {
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    if (lock1.tryLock()) {
                        try {
                            //如果获取成功则执行业务逻辑，如果获取失败，则释放lock1的锁，自旋重新尝试获得锁
                            if (lock2.tryLock()) {
                                try {
                                    System.out.println("Thread1：已成功获取 lock1 and lock2 ...");
                                    break;
                                } finally {
                                    lock2.unlock();
                                }
                            }
                        } finally {
                            lock1.unlock();
                        }
                    }
                    System.out.println("Thread1：获取锁失败，重新获取---");
                    try {
                        //防止发生活锁
                        TimeUnit.NANOSECONDS.sleep(new Random().nextInt(100));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                while (true) {
                    if (lock2.tryLock()) {
                        try {
                            //如果获取成功则执行业务逻辑，如果获取失败，则释放lock2的锁，自旋重新尝试获得锁
                            if (lock1.tryLock()) {
                                try {
                                    System.out.println("Thread2：已成功获取 lock2 and lock1 ...");
                                    break;
                                } finally {
                                    lock1.unlock();
                                }
                            }
                        } finally {
                            lock2.unlock();
                        }
                    }
                    System.out.println("Thread2：获取锁失败，重新获取---");
                    try {
                        //防止发生活锁
                        TimeUnit.NANOSECONDS.sleep(new Random().nextInt(100));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            deathLock();
        }
    }
}

该示例启动两个线程。线程1首先获取lock1的锁，然后再获取lock2的锁；线程2首先获取lock2的锁，然后再获取lock1的锁。这样如果这时线程1获得了lock1的锁，同时线程2获得lock2的锁，然后线程1尝试去获得lock2的锁，线程2尝试获得线程1的锁，就会造成死锁。

我们这里使用tryLock来获取两个锁，如果一个线程不能同时获取两把锁，那么就回退并自旋重新尝试（使用while循环）。再使用TimeUnit.NANOSECONDS.sleep(new Random().nextInt(100));随机休眠一段时间，从而降低发生活锁的可能性。如果处理成功，则使用break跳出循环。

示例二

使用tryLock(long timeout, TimeUnit unit) 方法来防止多线程死锁。

tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。

import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DeadLock2 {

    private static ReentrantLock lock1 = new ReentrantLock();
    private static ReentrantLock lock2 = new ReentrantLock();

    public static void deathLock() {
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    try {
                        if (lock1.tryLock(10, TimeUnit.MILLISECONDS)) {
                            try {
                                //如果获取成功则执行业务逻辑，如果获取失败，则释放lock1的锁，自旋重新尝试获得锁
                                if (lock2.tryLock(10, TimeUnit.MILLISECONDS)) {
                                    System.out.println("Thread1：已成功获取 lock1 and lock2 ...");
                                    break;
                                }
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            } finally {
                                if(lock2.isHeldByCurrentThread()){
                                    lock2.unlock();
                                }
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        if(lock1.isHeldByCurrentThread()){
                            lock1.unlock();
                        }
                    }
                    System.out.println("Thread1：获取锁失败，重新获取---");
                    try {
                        TimeUnit.NANOSECONDS.sleep(new Random().nextInt(100));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                while (true) {
                    try {
                        if (lock2.tryLock(10, TimeUnit.MILLISECONDS)) {
                            try {
                                //如果获取成功则执行业务逻辑，如果获取失败，则释放lock1的锁，自旋重新尝试获得锁
                                if (lock1.tryLock(10, TimeUnit.MILLISECONDS)) {
                                    System.out.println("Thread2：已成功获取 lock2 and lock1 ...");
                                    break;
                                }
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            } finally {
                                if(lock1.isHeldByCurrentThread()){
                                    lock1.unlock();
                                }
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        if(lock2.isHeldByCurrentThread()){
                            lock2.unlock();
                        }
                    }
                    System.out.println("Thread2：获取锁失败，重新获取---");
                    try {
                        TimeUnit.NANOSECONDS.sleep(new Random().nextInt(100));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            deathLock();
        }
    }
}

该示例同示例一。我们这里使用tryLock(long time, TimeUnit unit)来获取两个锁，如果一个线程不能同时获取两把锁，那么就回退并自旋重新尝试（使用while循环）。在使用TimeUnit.NANOSECONDS.sleep(new Random().nextInt(100));随机休眠一段时间，从而降低发生活锁的可能性。如果处理成功，则使用break跳出循环。

示例三

使用lockInterruptibly()获得锁，如果发生死锁，调用线程interrupt来消除死锁。

ReentrantLock.lockInterruptibly允许在等待时由其它线程调用等待线程的Thread.interrupt方法来中断等待线程的等待而直接返回，这时不用获取锁，而会抛出一个InterruptedException。而ReentrantLock.lock方法不允许Thread.interrupt中断,即使检测到Thread.isInterrupted,一样会继续尝试获取锁，失败则继续休眠。只是在最后获取锁成功后再把当前线程置为interrupted状态。

public class DeadLock3 {

    private static Lock lock1 = new ReentrantLock();
    private static Lock lock2 = new ReentrantLock();

    public static void deathLock() {
        new Thread() {
            @Override
            public void run() {
                try {
                    lock1.lockInterruptibly();
                    try {
                        TimeUnit.SECONDS.sleep(1);
                        lock2.lockInterruptibly();
                        System.out.println("thread 1 ...");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock2.unlock();
                    }

                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                } finally {
                    lock1.unlock();
                }
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                try {
                    lock2.lockInterruptibly();
                    try {
                        TimeUnit.SECONDS.sleep(1);
                        lock1.lockInterruptibly();
                        System.out.println("thread 1 ...");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock1.unlock();
                    }

                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                } finally {
                    lock2.unlock();
                }
            }
        }.start();
    }

    public static void main(String[] args) throws InterruptedException {
        deathLock();

        TimeUnit.SECONDS.sleep(2);
        checkDeadLock();
    }

    //基于JMX获取线程信息
    public static void checkDeadLock() {
        //获取Thread的MBean
        ThreadMXBean mbean = ManagementFactory.getThreadMXBean();
        //查找发生死锁的线程，返回线程id的数组
        long[] deadLockThreadIds = mbean.findDeadlockedThreads();
        System.out.println("---" + deadLockThreadIds);
        if (deadLockThreadIds != null) {
            //获取发生死锁的线程信息
            ThreadInfo[] threadInfos = mbean.getThreadInfo(deadLockThreadIds);
            //获取JVM中所有的线程信息
            Map<Thread, StackTraceElement[]> map = Thread.getAllStackTraces();
            for (Entry<Thread, StackTraceElement[]> entry : map.entrySet()) {
                for (int i = 0; i < threadInfos.length; i++) {
                    Thread t = entry.getKey();
                    if (t.getId() == threadInfos[i].getThreadId()) {
                        //中断发生死锁的线程
                        t.interrupt();
                        //打印堆栈信息       
                        // for (StackTraceElement ste : entry.getValue()) {
                        // // System.err.println("t" + ste.toString().trim());
                        // }
                    }

                }
            }
        }
    }
}

我们这里使用lockInterruptibly()方法来获取锁，我们这里使用线程1获取lock1 休眠1秒，嘻嘻按错2获取lock2 休眠1秒，1秒过后，然后线程1再获取lock2，线程2再去获得lock1就会发生死锁。这是我们又执行了checkDeadLock()方法，来检查JVM中是否有死锁，如果有死锁，则把发生死锁的线程执行interrupt()方法，使该线程响应中断，从而避免发生死锁。（实际应用中，检查死锁可以单独开启一个daemon线程，每间隔一段时间检查一下是否发生死锁，如果有则预警、记录日志、或中断该线程避免死锁）

本人简书blog地址：http://www.jianshu.com/u/1f0067e24ff8    
点击这里快速进入简书

GIT地址：http://git.oschina.net/brucekankan/
点击这里快速进入GIT

汲建帅
关注
专栏目录
Java并发编程(五) : 死锁、哲学家就餐问题、ReentrantLock (锁重入、锁超时、可中断、公平锁、条件变量)、同步模式之顺序控制
Guizy
01-10 2350
4.9 活跃性 活跃性相关的一系列问题都可以用ReentrantLock进行解决。 4.9.1 死锁 有这样的情况：一个线程需要同时获取多把锁，这时就容易发生死锁t1 线程获得A对象锁，接下来想获取B对象的锁；t2 线程获得B对象锁，接下来想获取A对象的锁例。Test28.java 4.9.2 检测死锁 检测死锁可以使用 jconsole工具；或者使用 jps 定位进程 id，再用 jstack 定位死锁：Test28.java 下面使用jstack工具进行演示 D:\我的项目\JavaLearing\ja
实现分布式锁的解决方案
赵广陆
01-04 1206
目录1. 分布式锁1.1 什么是分布式锁1.2 为什么要使用分布式锁1.3 分布式锁应具有的特性2 分布式锁实现方案2.1 数据库实现分布式锁2.2 ZooKeeper实现分布式锁2.3 Redis实现分布式锁2.3.1 版本一2.3.2 版本二2.3.3 版本三3. Redisson3.1 Redisson介绍3.2 Redisson分布式锁使用方式3.3 Lua脚本3.3.1 Lua简介3.3.2 Redis中使用Lua的好处3.3.3 如何在Redis中使用Lua 1. 分布式锁 1.1 什么是分布
ReentrantLock的使用
程序员的天堂
02-01 294
      ReentrantLock是一个可重入的互斥锁，重入锁是一种递归无阻塞的同步机制。ReentrantLock由最近成功获取锁，还没有释放的线程所拥有，当锁被另一个线程拥有时，调用lock的线程可以成功获取锁。如果锁已经被当前线程拥有，当前线程会立即返回。   重入锁的构造方法提供一个可选的公平参数：      公平情况下，操作会排一个队按顺序执行，来保证执行顺序。      ...
并发情况下ReentrantLock锁死锁
he91-com
09-25 1322
业务背景： 系统启动时需要向DRM服务器注册资源，同一个资源只能注册一次，不能重复注册。现在有两个资源需要注册，第一个资源为Profile阀门控制，第二个资源为模型阀门控制。 存在缺陷的代码： public class CommonConfig { /** 非公平锁 */ private static ReentrantLock lock = new Reentr...
ReentrantLock 死锁
最新发布
qq_42972573的博客
03-03 602
如果这两个线程同时运行，就有可能导致死锁的发生，因为线程1持有lock1而等待lock2的释放，而线程2持有lock2而等待lock1的释放，从而造成了相互等待的情况。，以避免长时间的等待。在发生死锁时，可以通过工具来检测和解决死锁问题，如使用jstack命令查看线程堆栈信息，或者使用工具分析线程转储文件等。为了避免死锁的发生，我们需要合理地设计锁的获取和释放顺序，避免出现循环等待的情况。在使用ReentrantLock时，如果不正确地处理锁的获取和释放，就有可能导致死锁的问题。
java ReentrantLock死锁示例
qq_33348135的博客
06-11 522
public class DeadLockForReentrantLock { private static final ReentrantLock lock1=new ReentrantLock(); private static final ReentrantLock lock2=new ReentrantLock(); public static void main(String[] args) { new Thread(()->{ .
基于Java的多线程程序死锁检查 JCarder.zip
06-17
理解并掌握Java多线程中的死锁现象及其解决方案对于开发高可用性的系统至关重要。`JCarder`作为一个有效的死锁检测工具，能够帮助开发者及时发现和修复死锁问题，提高程序的稳定性和性能。在实际开发中，结合使用...
缓存穿透解决方案和最佳实践(注解+AOP)
JavaMa的博客
05-07 1258
缓存穿透解决方案分析： 一步步分析改进AtomicBoolean,ReentrantLock,ConcurrentHashMap,Guava Striped,Redisson
分布式锁解决方案实战
weixin_40055163的博客
10-30 172
分布式锁解决方案实战 1 为什么要学习分布式锁解决方案 为了解决分布式架构带来的数据准确性问题！ 我们用synchronized或者 ReentrantLock 能解决问题吗？ 真实生产环境我们采用集群的方式去访问秒杀商品（nginx为我们做了负载均衡）。就会看到数据不一致的现象。如synchronized关键字的作用域其实是一个服务器进程（其实就是当前项目进程),在这个进程下面的所有线程都能够进行加锁。但是多进程就不行了。对于秒杀商品来说，这个值是固定的但是每个地区都可能有一台服务器。这样不同地区服务器
【Java多线程】ReentrantLock
Sampson_S的博客
10-18 408
ReentrantLock 在实现线程同步时，大多情况下使用的是Synchronized关键字实现，但是Synchronized的锁太过封闭，获得锁和释放锁都是系统自动的。所以为了更灵活的操作，在JDK1.5版本之后，就诞生了Lock接口以及其实现类。 lock接口也是对资源上锁的一种工具，它不同于Synchronized的隐式上锁与解锁，lock接口中的获取锁和释放锁，是需要手动去操作的。 Synchronized关键字的同步代码出现以下三种情况才会释放锁： 1、同步代码块执行完成，自动释放锁。 2、同
ReentrantLock解决死锁
weixin_43939924的博客
05-12 747
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
java项目开发案例经典_Java避免死锁实战之经典死锁案例-ReentrantLock
weixin_39866487的博客
12-11 271
产生死锁条件互斥条件不可剥夺条件请求和保持条件循环等待条件经典死锁案例package lock;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * 死锁 */public class DeadReentrantLock { public static void...
[Java多线程-基础] 避免线程死锁问题(ReentrantLock的使用)
私欲日生，如地上尘，一日不扫，便又有一层。着实用功，便见道无终穷，愈探愈深，必使精白无一毫不彻方可。
04-30 1234
ReentrantLock 的设计初衷是为了提供一种比 synchronized 更加灵活和可控的锁机制。与 synchronized 相比，ReentrantLock 提供了更多的功能，如可重入性、公平锁和中断锁等，使得它在某些场景下更适用。具体来说，ReentrantLock 可以通过以下方式提供更好的控制和灵活性：1. 可重入性：允许线程多次获得同一个锁，避免死锁情况的发生。2. 公平锁：可以实现公平的锁分配机制，避免某些线程长期无法获取到锁而产生的饥饿问题。
synchronized、ReentrantLock死锁的产生以及解决（一）
yeluowan的博客
08-12 1304
synchronized、ReentrantLock死锁
多把锁+ReentrantLock+活锁+死锁
weixin_57128596的博客
04-11 884
多把锁 并发度： 同一个时间节点上，可能与服务端进行交互的用户个数； 如何增强并发度： 首先明确，并发度增强无非就是交互个数在一个时间点上变多——>那么我们可以设置多把锁。目的就是同一时间上交互变多； 例子： package com.example.juc.Multi; import lombok.extern.slf4j.Slf4j; /** * @author diao 2022/4/10 */ @Slf4j(topic = "c.TestMultiLock") publ.
ReentrantLock替换synchronized解决多线程并发死锁，Java
Zhang Phil
11-01 471
Java并发多线程环境中，造成死锁的最简单的场景是：多线程中的一个线程T_A持有锁L1并且申请试图获得锁L2，而多线程中另外一个线程T_B持有锁L2并且试图申请获得锁L1。线程的锁申请操作是阻塞的，于是造成线程T_A和线程T_B无法正确获得想要的锁，两个线程被阻塞进入死锁状态。Java线程同步锁ReentrantLock和Condition中断等待程序前提条件满足_zhangphil的博客-CSDN博客。
# 死锁、ReentranLock（锁重入、锁超时、可中断、公平锁、条件变量）、同步模式之顺序控制
Hill__Cheung的博客
07-29 351
死锁、ReentranLock（锁重入、锁超时、可中断、公平锁、条件变量）、同步模式之顺序控制 多把锁 小故事 一间大屋子有两个功能：睡觉、学习，互不相干。 现在小南要学习、小女要睡觉，但如果只用一间屋子（一个对象锁）的话，那么并发度很低 小南获取锁之后，学完习之后，小女才能进来睡觉。 解决方法时准备多个房间（多个对象锁） @Slf4j(topic = "guizy.BigRoomTest") public class BigRoomTest { public static void m
分布式锁实现：基于Redis的解决方案
可重入特性允许持有锁的客户端再次获取同一把锁，防止死锁的发生。在Redis中，可以通过为每个客户端分配唯一的ID，并在获取锁时记录客户端ID，解锁时检查ID是否匹配来实现这一机制。 4. **Watchdog自动延期机制**...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值