什么是死锁？

        死锁就是指线程t1要使用的资源被线程t2占用，线程t2想使用的资源被线程 t1占用，这就像两股绳子拧在一起，解不开了；

死锁代码案例：

public class Test {
    public static void main(String[] args){
        Object lock1 = new Object();
        Object lock2 = new Object();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized(lock1){
                    System.out.println("线程t1拿到lock1");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程t1尝试在拿到lock1的情况下获取lock2...");
                    synchronized(lock2){
                        System.out.println("线程t1拿到lock2");
                    }
                }
            }
        });


        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized(lock2){
                    System.out.println("线程t2拿到lock2");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程t2尝试在拿到lock2的情况下获取lock1...");
                    synchronized(lock1) {
                        System.out.println("线程t2拿到lock1");
                    }
                }
            }
        });
        t1.start();
        t2.start();
    }
}

出现死锁的原因

        1.互斥使用，lock1被线程1 占用，线程2 就不能用了；

        2.不可抢占，lock1被线程1 占用，线程2 不能把lock1抢过来，只能阻塞等待线程1主动释放；

        3.请求拥有条件， lock1被线程1占用，并且在不释放lock1的前提下想获取其他资源（例如lock2）；

        4.循环等待，线程1 等待线程2释放锁，线程2 要释放锁需要等待线程3释放锁，线程3释放锁需要等待线程1释放锁（多个线程在获取资源的时候形成环）；

教你如何定位死锁位置~

使用jdk内置工具检查——jconsole.exe

 经查询可知死锁的位置：（如下图）

死锁解决方法

        一个普适的办法便是从循环等待这里入手——打破循环等待！

        咱可以给锁编号，约定加多个锁的时候，必须先加编号小的锁，后加编号大的锁，就可以有效避免循环等待；（本质：两个线程竞争同一把锁，修改为并行，就可以有效避免环路）

例如：刚刚讲到的死锁代码案例，那么解决办法就是，让锁按照编号顺序进行获取~

如下代码：（解决死锁问题）

public class Test {
    public static void main(String[] args){
        Object lock1 = new Object();
        Object lock2 = new Object();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized(lock1){
                    System.out.println("线程t1拿到lock1");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程t1尝试在拿到lock1的情况下获取lock2...");
                    synchronized(lock2){
                        System.out.println("线程t1拿到lock2");
                    }
                }
            }
        });


        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized(lock1){
                    System.out.println("线程t2拿到lock1");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程t2尝试在拿到lock1的情况下获取lock2...");
                    synchronized(lock2) {
                        System.out.println("线程t2拿到lock2");
                    }
                }
            }
        });
        t1.start();
        t2.start();
    }
}

执行结果：