死锁产生与解决

一、死锁定义

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

代码演示：

import java.util.concurrent.TimeUnit;

/**
 * 死锁示例
 */
public class Thread16 {
    public static void main(String[] args) {
        Object lockA = new Object();
        Object lockB = new Object();
        Thread t1 = new Thread(() -> {
            //1.占有1把锁(占有锁A)
            synchronized (lockA){
                System.out.println("线程1：获得锁A。");
                //休眠1s(让线程2有时间先占有锁B)
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //2.试图获取线程2的锁B
                synchronized (lockB){
                    System.out.println("线程1：获得锁B。");
                }
            }
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            //1.占有1把锁（占有锁B）
            synchronized (lockB){
                System.out.println("线程2：获得锁B!");
                //休眠1s（让线程1有充足时间得到锁A）
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //2.试图获取线程1的锁A
                synchronized (lockA){
                    System.out.println("线程2：获得锁A!");
                }
            }
        });
        t2.start();
    }
}

二、死锁产生的原因

主要由以下 4 个因素造成：
1.互斥条件
⼀个资源只能被⼀个线程占有，当这个资源被占⽤之后其他线程就只能等待。
2.不可被剥夺条件
当⼀个线程不主动释放资源时，此资源⼀直被拥有线程占有。
3. 请求并持有条件
线程已经拥有了⼀个资源之后，又尝试请求新的资源。
4.环路等待条件
产⽣死锁⼀定是发⽣了线程资源环形链。

以上四个条件是导致死锁的必要条件，要形成死锁，以上4个条件缺一不可。

三、死锁的解决

分析：
1.互斥条件（系统特性，不可打破）
2.不可被剥夺条件（系统特性，不可打破）
3. 请求并持有条件**（人为能控制，可以打破）**
4.环路等待条件**（人为能控制，可以打破）**

综上：可以通过打破环路等待条件和请求并持有条件来解决死锁问题。

3.1打破请求并持有条件

让线程1和线程2都只获得各自的锁，不再试图访问对方的锁

import java.util.concurrent.TimeUnit;

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) {
                }

//                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) {
                }

//                synchronized (lockA){
//                    System.out.println("线程2：得到锁A");
//                    //业务代码...
//
//                    System.out.println("线程2：释放锁A");
//                }

                System.out.println("线程2：释放锁B");
            }
        },"线程2");
        t2.start();
    }
}

3.2打破环路等待条件（顺序锁）

环路等待条件产生死锁的流程：
线程1请求顺序：先请求锁A再请求锁B
线程2请求顺序：先请求锁B再请求锁A

打破环路等待条件后的执行流程：
a.线程1得到锁A，线程2进入阻塞状态
b.线程1在没有释放锁A的请求下，又得到了锁B，线程2还在阻塞状态
c.线程1执行完了业务释放了锁B，线程2还在阻塞状态
d.线程1又释放了锁A，执行结束
e.线程2得到了锁A，继续执行
f.线程2又得到了锁B
g.线程2释放了锁B
h.线程2释放了锁A，执行结束

代码演示：

import java.util.concurrent.TimeUnit;

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) {
                }

                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) {
                }

                synchronized (lockB){
                    System.out.println("线程2：得到锁B");
                    //业务代码...

                    System.out.println("线程2：释放锁B");
                }

                System.out.println("线程2：释放锁A");
            }
        },"线程2");
        t2.start();
    }
}