点击上方蓝色字体，选择“标星公众号”

优质文章，第一时间送达

死锁问题

死锁定义

多线程编程中，因为抢占资源造成了线程无限等待的情况，此情况称为死锁。

死锁举例

注意：线程和锁的关系是：一个线程可以拥有多把锁，一个锁只能被一个线程拥有。

当两个线程分别拥有一把各自的锁之后，又尝试去获取对方的锁，这样就会导致死锁情况的发生，具体先看下面代码：

/**
 * 线程死锁问题
 */
public class DeadLock {
    public static void main(String[] args) {
        //创建两个锁对象
        Object lock1 = new Object();
        Object lock2 = new Object();

        //创建子线程
        /*
        线程1：①先获得锁1 ②休眠1s，让线程2获得锁2 ③线程1尝试获取锁2 线程2同理
         */
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //线程1业务逻辑
                synchronized(lock1){
                    System.out.println("线程1得到了锁子1");
                    try {
                        //休眠1s，让线程2先得到锁2
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程1尝试获取锁2...");
                    synchronized(lock2){
                        System.out.println("线程1获得了锁2!");
                    }
                }
            }
        },"线程1");


        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //线程2业务逻辑
                synchronized(lock2){
                    System.out.println("线程2得到了锁子2");
                    try {
                //休眠1s，让线程1先得到锁1；因为线程是并发执行我们不知道谁先执行
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程2尝试获取锁1...");
                    synchronized(lock1){
                        System.out.println("线程2获得了锁1");
                    }
                }
            }
        },"线程2");
        thread1.start();
        thread2.start();
    }
}

程序运行结果如下：

可以看出，线程1尝试获取了锁2，线程2尝试获取了锁1，但是二者并没有获取到对方的锁；这就发生了所谓的“死锁”！

如何排查死锁

想要排查死锁具体细节，可以通过三个工具（位于jdk安装路径bin目录）去排查，现在就给大家介绍一下：

1.jconsole

可以看出，线程1和线程2发生了死锁，死锁发生的位置一目了然

2.jvisualvm

可以看出，发生了死锁，线程1和线程2尝试获取的锁是对方的锁。

3.jmc

可以看出，同样检测出了死锁情况
无论是用哪个工具排查死锁情况都是OK的。

死锁发生的条件

1.互斥条件（一个锁只能被一个线程占有，当一个锁被一个线程持有之后，不能再被其他线程持有）；
2.请求拥有（一个线程拥有一把锁之后，又去尝试请求拥有另外一把锁）；可以解决
3.不可剥夺（一个锁被一个线程占有之后，如果该线程没有释放锁，其他线程不能强制获得该锁）；
4.环路等待条件（多线程获取锁时形成了一个环形链）可以解决

怎么解决死锁问题？

环路等待条件相对于请求拥有更容易实现，那么通过破坏环路等待条件解决死锁问题
破坏环路等待条件示意图：

针对于上面死锁举例中代码，解决死锁，具体看下面代码：

public class SolveDeadLock {
    public static void main(String[] args) {
        //创建两个锁对象
        Object lock1 = new Object();
        Object lock2 = new Object();

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //线程1业务逻辑
                synchronized(lock1){
                    System.out.println("线程1得到了锁子1");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程1尝试获取锁2...");
                    synchronized(lock2){
                        System.out.println("线程1获得了锁2!");
                    }
                }
            }
        },"线程1");

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //线程2业务逻辑
                synchronized(lock1){
                    System.out.println("线程2得到了锁子1");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程2尝试获取锁2...");
                    synchronized(lock2){
                        System.out.println("线程2获得了锁2");
                    }
                }
            }
        },"线程2");
        thread1.start();
        thread2.start();
    }
}

程序运行结果如下：

可以看出，通过破坏环路等待条件完美解决了死锁问题

线程通讯机制（wait/notify/notifyAll）

定义

线程通讯机制：一个线程的动作可以让另外一个线程感知到，这就是线程通讯机制。
wait()：让当前线程进入休眠等待状态；
notify()：唤醒当前对象上的休眠等待线程；
notifyAll()：唤醒当前对象上的所有休眠等待线程。

LockSupport

LockSupport是对wait()的升级，无需加锁也无需释放锁；

LockSupport.park()让线程休眠，和wait()一样会让线程进入WAITING状态；
LockSupport.unpark()唤醒线程，可以唤醒对象上指定的休眠等待线程；（优势）

LockSupport与wait()区别

wait()与LockSupport的区别：

相同点：
1.二者都可以让线程进入休眠等待状态；
2.二者都可以传参或者不传参，让线程都会进入到WAITING状态。
不同点：
1.wait()需要配合加锁一起使用，LockSupport无需加锁；
2.wait()只能唤醒对象的随机休眠线程和全部线程，LockSupport可以唤醒对象的指定休眠线程。

本文链接：

https://blog.csdn.net/weixin_44874269/article/details/116639326

粉丝福利：Java从入门到入土学习路线图

👇👇👇

👆长按上方微信二维码 2 秒

感谢点赞支持下哈

Java多线程死锁问题