Java死锁的产生原因及解决方法总结

 更新时间:2023年11月06日 09:24:22   作者:一一哥Sun  
Java中的死锁是指多个线程同时占用一些共享资源且彼此相互等待,从而导致所有的线程都被阻塞,不能继续执行程序的情况,本文小编给大家介绍了Java死锁的产生原因及解决方法总结,需要的朋友可以参考下

一. 死锁

1. 概念

Java中的死锁是指多个线程同时占用一些共享资源且彼此相互等待,从而导致所有的线程都被阻塞,不能继续执行程序的情况。这就好比在一个十字路口,没有交警也没有红绿灯指挥通行,所有的车辆都占据道路且互相等待对方让出路权,此时就很容易造成道路堵死,这其实就是道路的“死锁”。如下图所示:

2. 死锁案例

虽然我们现在已经知道了死锁的概念,但具体什么时候会产生死锁,相信很多小伙伴肯定还是弄不不清楚。所以接下来就给大家设计一个会产生死锁的代码案例,如下所示:

/**
 * @author 一一哥Sun
 * @company 千锋教育
 */
public class Demo21 {
    // 定义2个锁定的对象
    private Object lock1 = new Object();
    private Object lock2 = new Object();

    public void method1() {
        // 锁定对象1
        synchronized (lock1) {
            System.out.println("Method 1: 获取对象lock1的锁");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 锁定对象2
            synchronized (lock2) {
                System.out.println("Method 1: 获取对象lock2的锁");
            }
        }
     }

    public void method2() {
        // 锁定对象2
        synchronized (lock2) {
            System.out.println("Method 2: 获取对象lock2的锁");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 锁定对象1
            synchronized (lock1) {
                System.out.println("Method 2: 获取对象lock1的锁");
            }
        }
    }

    public static void main(String[] args) {
        final Demo21 example = new Demo21();

        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                example.method1();
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                example.method2();
            }
        });

        //开启线程
        thread1.start();
        thread2.start();
    }
}

在上面的案例中,定义了两个方法method1和method2,这两个方法分别占用了lock1和lock2两个锁,并且在执行过程中会互相等待对方的锁,从而形成了死锁。如果我们运行该程序,就会看到两个线程互相等待对方释放自己占用的锁,这最终会导致所有的线程都被阻塞。上述案例中死锁的产生原因,如下图所示:

根据上面的案例,你可以总结出会导致死锁的条件吗?我们继续往下看。

3. 产生条件

其实一个Java程序要想产生死锁,也并不是那么容易,只有同时满足以下条件才行:

互斥条件:多个线程需同时访问一个共享资源,但每次只能有一个线程访问该资源;

请求和保持条件:一个线程在持有一个资源的同时,还想请求另一个资源;

不可剥夺条件:已经分配的资源不能被其他线程剥夺;

循环(环路)等待条件:多个线程形成了一个循环等待资源的链路,例如线程A等待线程B释放自己所占用的资源,线程B等待线程C释放自己所占用的资源,而线程C又等待线程A释放自己所占用的资源。

只有同时满足了以上条件,程序中才会产生死锁。既然我们现在知道了死锁的产生条件,那又该怎么解决呢?

4. 解决办法

我们知道,当出现死锁时,所有的线程都会被阻塞,且不能再继续执行程序,所以我们必须解决死锁。一般情况下,我们可以通过以下方式来避免线程死锁:

避免使用多个锁;

尽可能减少同步代码块的长度;

尝试改变锁的获取顺序,避免线程之间形成循环等待;

使用定时锁,当等待时间超过一定的时间值后就自动释放锁

以上就是打破死锁条件的解决办法,但是具体放到Java代码中又是怎么样的呢?接下来就把上面产生死锁的代码修改一下,解决死锁问题。

5. 案例优化

接下来就把上面产生死锁的案例优化一下,解决掉案例中的死锁,代码如下:

public class Demo22 {
    // 定义2个锁定的对象
    private Object lock1 = new Object();
    private Object lock2 = new Object();

    public void method1() {
        //锁定对象
        synchronized(lock1) {
            System.out.println("Method 1: 获取对象锁lock 1");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            synchronized(lock2) {
                System.out.println("Method 1: 获取对象锁lock 2");
            }
        }
    }

    public void method2() {
        synchronized(lock1) {
            System.out.println("Method 2: 获取对象锁lock 1");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            synchronized(lock2) {
                System.out.println("Method 2: 获取对象锁lock 2");
            }
        }
    }

    public static void main(String[] args) {
        final Demo22 demo = new Demo22();

        //定义两个线程
        Thread thread1 = new Thread(new Runnable() {
        	@Override
            public void run() {
            	demo.method1();
            }
        });

        Thread thread2 = new Thread(new Runnable() {
        	@Override
            public void run() {
            	demo.method2();
            }
        });

        //开启线程
        thread1.start();
        thread2.start();
    }
}

上面的这个案例与之前的案例代码几乎一样,但与之不同的是,本案例中的方法method1和method2,都是先占用lock1锁,再占用lock2锁,这样就避免了死锁的发生,因为这两个方法占用锁的顺序是一致的。所以我们在编写多线程代码时,需要特别注意线程死锁的问题,避免影响程序的正常执行。

二. 结语

至此,小编就把Java中的死锁给大家讲解完毕了,现在你明白了吗?我们在面试时经常会有面试官考察死锁相关的内容,比如死锁是怎么产生的?如何避免死锁?所以今天的内容很重要,请各位一定要牢牢掌握哦。

以上就是Java死锁的产生原因及解决方法总结的详细内容,更多关于Java死锁的资料请关注脚本之家其它相关文章!

相关文章

  • IDEA怎么生成UML类图的实现

    IDEA怎么生成UML类图的实现

    这篇文章主要介绍了IDEA怎么生成UML类图的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2020-09-09
  • SpringBoot整合Netty服务端的实现示例

    SpringBoot整合Netty服务端的实现示例

    Netty提供了一套完整的API,用于处理网络IO操作,如TCP和UDP套接字,本文主要介绍了SpringBoot整合Netty服务端的实现示例,具有一定的参考价值,感兴趣的可以了解一下
    2024-07-07
  • Java中finally和return的关系实例解析

    Java中finally和return的关系实例解析

    这篇文章主要介绍了Java中finally和return的关系实例解析,总结了二者的关系,然后分享了相关代码示例,小编觉得还是挺不错的,具有一定借鉴价值,需要的朋友可以参考下
    2018-02-02
  • Java内存分配多种情况的用法解析

    Java内存分配多种情况的用法解析

    这篇文章主要介绍了Java内存分配多种情况的用法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2019-11-11
  • 详解SpringBoot程序启动时执行初始化代码

    详解SpringBoot程序启动时执行初始化代码

    这篇文章主要介绍了详解SpringBoot程序启动时执行初始化代码,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2018-09-09
  • Java基于fork/koin类实现并发排序

    Java基于fork/koin类实现并发排序

    这篇文章主要介绍了Java基于fork/koin类实现并发排序,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-02-02
  • MyBatis获取自动生成的(主)键值的方法

    MyBatis获取自动生成的(主)键值的方法

    本文主要介绍了MyBatis获取自动生成的(主)键值的方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2023-04-04
  • Java String类简单用法实战示例【字符串输出、比较】

    Java String类简单用法实战示例【字符串输出、比较】

    这篇文章主要介绍了Java String类简单用法,结合具体实例形式分析了Java使用String类实现字符串的输出和比较功能相关操作技巧,需要的朋友可以参考下
    2019-07-07
  • 为spring get请求添加自定义的参数处理操作(如下划线转驼峰)

    为spring get请求添加自定义的参数处理操作(如下划线转驼峰)

    这篇文章主要介绍了为spring get请求添加自定义的参数处理操作(如下划线转驼峰),具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2020-09-09
  • springboot集成nacos读取nacos配置数据的原理

    springboot集成nacos读取nacos配置数据的原理

    这篇文章主要介绍了springboot集成nacos读取nacos配置数据的原理,文中有详细的代码流程,对大家学习springboot集成nacos有一定的帮助,需要的朋友可以参考下
    2023-05-05

最新评论