【多线程——死锁的产生、解决方法】

1.死锁定义：

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。

2.死锁代码：

import java.util.concurrent.TimeUnit;

/**
 * 手写死锁
 */
public class ThreadDemo16 {
    public static void main(String[] args) {
        Object lockA = new Object();
        Object lockB = new Object();

        Thread thread1 = new Thread(() -> {
            //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！");
                }
            }
        }, "线程1");
        thread1.start();

        Thread thread2 = new Thread(() -> {
            //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!");
                }
            }
        }, "线程2");
        thread2.start();
    }
}

使用jconsole查看死锁：

3.死锁产生的条件

1.互斥条件：一个资源只能同一时间被一个线程占有，当这个资源被占有之后其他线程就只能等待。
2.不可被剥夺条件：一个资源被占用之后，如果这个线程不主动释放资源时，此资源一直被拥有的线程占用，其他线程不能得到此资源。
3.请求并持有条件：当一个线程拥有了一个资源后，又尝试请求其他资源。
4.环路等待条件：多个线程在请求资源的情况下，形成了线程资源环路链。
以上4 个条件是导致死锁的必要条件，要形成死锁，以上4个条件缺一不可。

4.如何解决死锁问题

改变死锁中的任意一个或者多个条件就可以解决死锁，其中可以被修改的条件只有两个：请求并持有条件和环路等待条件，其他条件是系统特质，不可改变。

4.1 通过打破请求并持有条件来解决死锁：

4.2 通过修改获取锁的有序性来改变环路等待条件：

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();


    }
}

死锁时线程的请求顺序为：
线程1：先请求锁A、再请求锁B
线程2：先请求锁B、再请求锁A

修改获得锁的顺序后线程的请求顺序为：
线程1：先请求锁A、再请求锁B
线程2：先请求锁A、再请求锁B

得到锁的过程为：