多线程——死锁详解

目录

1.什么是死锁

2.死锁的四个必要条件

如何破除死锁 

4.可重入和不可重入 

5.死锁检测

1、JConsole工具

1、Jstack命令

---

死锁，既是面试中经常考的问题，又是工作中息息相关的问题 一旦程序死锁，就会导致线程无法继续执行后续工作了，程序势必有严重bug。

1.什么是死锁

死锁是指两个或两个以上的进程在执⾏过程中，由于竞争资源或者由于彼此通信⽽造成的⼀种阻塞的现象，若⽆外⼒作⽤，它们都将⽆法推进下去。（也就是两个线程拥有锁的情况下，⼜在尝试获取对⽅锁，从⽽造成程序⼀直阻塞的情况。）

---

2.死锁的四个必要条件

（四个元素同时具备，才出现死锁）

1.互斥使用。⼀个资源只能被⼀个线程占有，当这个资源被占⽤之后其他线程就只能等待。线程1拿到了锁，线程2就得等着（锁的基本特性）。

2.不可抢占。当⼀个线程不主动释放资源时，此资源⼀直被拥有线程占有，其他线程不能得到此资源。线程1拿到锁之后，必须是线程1主动释放。不能是线程2强行把锁获取到。

3.请求和保持。 线程已经拥有了⼀个资源之后，又尝试请求新的资源。线程1拿到锁A之后，在尝试获取锁B，A这把锁还是保持的（不会因为锁B就把锁A给释放了）。

4.循环等待。线程1尝试获取到锁A和锁B，线程2尝试获取到锁B和锁A。线程1在获取B的时候等待线程2释放B；同时线程2在获取A的时候等待线程1释放A。

说是四个条件，实际上就是一个条件，前三个条件都是锁的基本特性（对于synchronized这把锁来说，前三点也动不了）。

如何避免死锁？

1.请求和保持： 可以改变（人为控制）。

2.循环等待： 可以改变（人为控制）。

最好的并发就是，打破必要条件！突破口：打破循环等待。

办法：给锁编号，然后指定一个固定的顺序（比如从小到大）来加锁。

任意线程加多把锁的时候，都让线程遵守上述顺序，此时循环等待自然破除！ 

---

如何破除死锁 

以下的代码发生了死锁：

两个线程 两把锁，t1和t2各自针对 锁A 和 锁B 加锁，在尝试获取对方的锁

public class UnDeadLock {
    public static void main(String[] args) {
        Object lockA = new Object();
        Object lockB = new Object();
 
        Thread t1 = new Thread(() -> {
            synchronized (lockA) {
                System.out.println("线程1：得到锁A");
                //业务代码
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lockB) {
                    System.out.println("线程1：得到锁B");
                    //业务代码
                    System.out.println("线程1：释放锁B");
                }
                System.out.println("线程1：释放锁A");
            }
        },"线程1");
        t1.start();
 
        Thread t2 = new Thread(() -> {
            synchronized (lockB) {
                System.out.println("线程2：得到锁B");
                //业务代码
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lockA) {
                    System.out.println("线程2：得到锁A");
                    //业务代码
                    System.out.println("线程2：释放锁A");
                }
                System.out.println("线程2：释放锁A");
            }
        },"线程2");
        t2.start();
    }
}
 
输出
    线程1：得到锁A
    线程2：得到锁B
（......没有结束）

解决办法： 

1. 修改获取锁请求并持有条件：(直接取消线程1和线程2获取对方的锁)

解决死锁方法：破坏请求并持有条件
 
public class UnDeadLock {
    public static void main(String[] args) {
        Object lockA = new Object();
        Object lockB = new Object();
 
        Thread t1 = new Thread(() -> {
            synchronized (lockA) {
                System.out.println("线程1：得到锁A");
                //业务代码
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
//                synchronized (lockB) {
//                    System.out.println("线程1：得到锁B");
//                    //业务代码
//                    System.out.println("线程1：释放锁B");
//                }
                System.out.println("线程1：释放锁A");
            }
        },"线程1");
        t1.start();
 
        Thread t2 = new Thread(() -> {
            synchronized (lockB) {
                System.out.println("线程2：得到锁B");
                //业务代码
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
//                synchronized (lockA) {
//                    System.out.println("线程2：得到锁A");
//                    //业务代码
//                    System.out.println("线程2：释放锁A");
//                }
                System.out.println("线程2：释放锁B");
            }
        },"线程2");
        t2.start();
    }
}
 
输出：
    线程1：得到锁A
    线程2：得到锁B
    线程2：释放锁B
    线程1：释放锁A

  2. 修改获取锁的有序性来改变环路等待条件：

解决死锁方法：修改获取锁的有序性来改变环路等待条件
 
public class UnDeadLock2 {
    public static void main(String[] args) {
        Object lockA = new Object();
        Object lockB = new Object();
 
        Thread t1 = new Thread(() -> {
            synchronized (lockA) {
                System.out.println("线程1：得到锁A");
                //业务代码
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lockB) {
                    System.out.println("线程1：得到锁B");
                    //业务代码
                    System.out.println("线程1：释放锁B");
                }
                System.out.println("线程1：释放锁A");
            }
        },"线程1");
        t1.start();
 
        Thread t2 = new Thread(() -> {
            synchronized (lockA) {
                System.out.println("线程2：得到锁A");
                //业务代码
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lockB) {
                    System.out.println("线程2：得到锁B");
                    //业务代码
                    System.out.println("线程2：释放锁B");
                }
                System.out.println("线程2：释放锁A");
            }
        },"线程2");
        t2.start();
    }
}
 
输出：
    线程1：得到锁A
    线程1：得到锁B
    线程1：释放锁B
    线程1：释放锁A
    线程2：得到锁A
    线程2：得到锁B
    线程2：释放锁B
    线程2：释放锁A

---

3.三个死锁典型情况

1.一个线程，一把锁，连续加锁两次。如果锁是不可重入锁，就会死锁，幸运的是，synchronized是可重入锁。

2.两个线程，两把锁，线程吃获取锁A，线程2获取锁B，此时线程1尝试获取B，线程2尝试获取锁A。

3.N个线程，M把锁。一种典型情况：哲学家就餐问题。

---

4.可重入和不可重入 

 可重入：

1.一个线程，一把锁，连续加锁两次，如果锁是不可重入锁，就会死锁 Java中synchronized和ReentrantLock都是可重入锁，这个现象演示不了。

2.两个线程两把锁，t1和t2各自先针对锁A和锁B加锁，在尝试获取对方的锁。

3.多个线程，多把锁(相当于2的一般情况)。 

---

5.死锁检测

1、JConsole工具

Jconsole是JDK自带的监控工具，在JDK/bin目录下可以找到。针对死锁问题，需要借助jconsole这样的工具来定位，看线程的状态和调用栈，可以分析出代码哪里死锁了。

1、Jstack命令

jstack是java虚拟机自带的一种堆栈跟踪工具。jstack用于打印出给定的java进程ID或core file或远程调试服务的Java堆栈信息。 Jstack工具可以用于生成java虚拟机当前时刻的线程快照。线程快照是当前java虚拟机内每一条线程正在执行的方法堆栈的集合，生成线程快照的主要目的是定位线程出现长时间停顿的原因，如线程间死锁、死循环、请求外部资源导致的长时间等待等。 线程出现停顿的时候通过jstack来查看各个线程的调用堆栈，就可以知道没有响应的线程到底在后台做什么事情，或者等待什么资源。