java死锁和解决方案

java死锁

死锁的定义

死锁是指两个或者两个以上的线程在执行过程中，因为争夺资源而造成的相互等待的现象，再无外力作用的情况下，这些线程会一直等待而无法继续运行下去。
如图所示：

示例：死锁的代码

public class Demo {
    public static Object locker1=new Object();
    public static Object locker2=new Object();
    public static void main(String[] args) {
        Thread t1=new Thread(()->{
            System.out.println("线程1尝试获取locker1！");
           synchronized (locker1){
               try {
                   System.out.println("线程1获取locker1成功！");
                   Thread.sleep(1000);//sleep阻塞等待，但是locker1加锁未释放
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println("线程1尝试获取locker2！");
               synchronized (locker2){
                   System.out.println("线程1获取locker2成功！");
               }
           }
        });

        Thread t2=new Thread(()->{
            System.out.println("线程2尝试获取locker2！");
            synchronized (locker2){
                System.out.println("线程2获取locker2成功！");
                try {
                    Thread.sleep(1000);//sleep阻塞等待，但是locker2加锁未释放
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程2尝试获取locker1！");
                synchronized (locker1){
                    System.out.println("线程2获取locker1成功！");
                }
            }

        });
        t1.start();
        t2.start();
    }
}

运行结果：

结果分析： 很明显死锁了，程序没有结束。线程1获取了locker1对象锁未释放，同时还想尝试获取locker2对象锁。而此时线程2获取locker2对象锁未释放，同时还想尝试获取locker1对象锁，所以线程1和线程2就因为相互等待对方已经持有的锁资源释放，从而进入了死锁状态。

死锁产生必须具备的四个条件

1.互斥条件： 资源只能同时由一个线程占用，如果此时还有其他线程请求获取该资源，只能等待，直至占有资源的线程释放该资源。
2.不可剥夺条件（不可抢占）： 线程获取的资源在自己使用完之前不能被其他线程抢占，只有自己使用完后才由自己主动释放该资源。
3.请求并持有条件（请求和保持）： 线程已经持有了至少一个资源，但是同时又提出新的资源请求，但是新资源已经被其他线程占有，所以当前线程会被阻塞，但是阻塞的同时并不释放自己已经获取的资源。
4.环路等待条件（循环等待）： 线程1等待线程2释放资源，线程2等待线程3释放资源…线程n等待线程1释放资源，形成了环路。
以上的4个条件中条件1和条件2，是锁资源的基本特性，不能更改，于是我们只能从条件3和条件4中需求解法。

死锁解决方案

1.针对请求和保持的条件： 我们可以在线程1想要获取其他资源的前，把自己持有的资源先释放了。
2.针对循环等待条件： 我们可以约定好资源获取的顺序，例如给锁资源编号，约定多个锁的时候，必须先申请获取编号小的锁资源，后申请编号大的锁资源。
破解死锁示例1：针对请求和保持条件

    public static Object locker1=new Object();
    public static Object locker2=new Object();
    public static void main(String[] args) {
        Thread t1=new Thread(()->{
            System.out.println("线程1尝试获取locker1！");
            synchronized (locker1) {
                try {
                    System.out.println("线程1获取locker1成功！");
                    Thread.sleep(1000);//sleep阻塞等待，但是locker1加锁未释放
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            System.out.println("线程1尝试获取locker2！");
            synchronized (locker2){
                System.out.println("线程1获取locker2成功！");
            }

        });

        Thread t2=new Thread(()->{
            System.out.println("线程2尝试获取locker2！");
            synchronized (locker2) {
                System.out.println("线程2获取locker2成功！");
                try {
                    Thread.sleep(1000);//sleep阻塞等待，但是locker2加锁未释放
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            System.out.println("线程2尝试获取locker1！");
            synchronized (locker1){
                System.out.println("线程2获取locker1成功！");
            }


        });
        t1.start();
        t2.start();
    }

执行结果：

破解死锁示例2.：针对循环等待条件

public class Demo1 {
    public static Object locker1=new Object();
    public static Object locker2=new Object();
    public static void main(String[] args) {
        Thread t1=new Thread(()->{
            System.out.println("线程1尝试获取locker1！");
            synchronized (locker1){
                try {
                    System.out.println("线程1获取locker1成功！");
                    Thread.sleep(1000);//sleep阻塞等待，但是locker1加锁未释放
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1尝试获取locker2！");
                synchronized (locker2){
                    System.out.println("线程1获取locker2成功！");
                }
            }
        });

        Thread t2=new Thread(()->{
            System.out.println("线程2尝试获取locker1！");
            synchronized (locker1){
                System.out.println("线程2获取locker1成功！");
                try {
                    Thread.sleep(1000);//sleep阻塞等待，但是locker2加锁未释放
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程2尝试获取locker2！");
                synchronized (locker2){
                    System.out.println("线程2获取locker2成功！");
                }
            }

        });
        t1.start();
        t2.start();
    }
}

执行结果：