死锁的产生

我们先从简单的死锁最后到难一些的死锁问题开始展开讨论。

首先一个线程，一把锁，因为多次加锁而导致死锁问题，由于Java 的synchronized 实现了可重入锁，因此这个死锁问题就不存在了，意味着当一个线程拥有一把锁时，可以对这个锁进行多次加锁操作，而不会发生死锁问题，在上一篇文章中也仔细讨论了，这里不赘述了。

接下来就是两个线程，两把锁，两个线程都想获得对方的锁的时候，就会发生死锁问题，我们来看一下代码：

    public static void main(String[] args) {
        Object locker1 = new Object();
        Object locker2 = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (locker1) {
                System.out.println("t1 线程获得了 锁1");
                synchronized (locker2) {
                    System.out.println("t1 线程成功获得了 锁2");
                }
            }
        });
        
        Thread t2 = new Thread(() -> {
           synchronized(locker2) {
               System.out.println("t2 线程获得了 锁2");
               synchronized(locker1) {
                   System.out.println("t2 线程成功获得了 锁1");
               }
           }
        });
        
        t1.start();
        t2.start();
    }

没想到，居然执行成功了！！！

为什么会执行成功呢？
因为t1.start() 的速度太快了，直接就获得了两把锁，t2 此时都还没开始执行就结束了。
但是这是一种大概率的情况，如果发生小概率事件，也就是死锁状态，程序就会一直卡住在这里

小概率事件是指什么？
理论上，当 t1 线程和 t2 线程开始执行的时候，t1 会获得 locker1, t2 获得 locker2 , 由于 t1 线程还需要获得 locker2 , t2 线程还需要获得 locker1，但是都被对方先拿到了，此时着两个线程就无法继续执行下去，就会导致两个线程一直处于阻塞状态

如何看到两个线程阻塞状态？
很简单，在 t1 线程加个 sleep, 保证 t2 线程获得了 locker2

    public static void main(String[] args) {
        Object locker1 = new Object();
        Object locker2 = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (locker1) {
                System.out.println("t1 线程获得了 锁1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker2) {
                    System.out.println("t1 线程成功获得了 锁2");
                }
            }
        });

        Thread t2 = new Thread(() -> {
           synchronized(locker2) {
               System.out.println("t2 线程获得了 锁2");
               synchronized(locker1) {
                   System.out.println("t2 线程成功获得了 锁1");
               }
           }
        });

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

我们打开 Jconsole

我们看到两个线程进入了 BLOCKED 状态（阻塞状态），并且还能直到代码阻塞在第几行。

这就是死锁问题

最后n 个线程，m 把锁，这个就要拿出经典案例：哲学家就餐问题

现在图中有 6 位哲学家，每位哲学家的左手和右手两边各有一根筷子，哲学家此时会有两个事件随机发生，一个事件是拿起左手和右手的筷子吃面，另一个事件就是思考哲学问题（不吃面）

现在我们试想一个极端的情况，如果每一个哲学家此时都想吃面，他们同时拿起左边的筷子，这时候，没有一位哲学家是拿到一双筷子的，并且没有一位哲学家会放弃自己左手的筷子，都在等别人放下的筷子之后拿起来吃面，这时候谁都吃不成。

上面就是经典的哲学家问题，上面的哲学家可以类比我们的线程，筷子就是锁，虽然这种死锁发生的概率很低，但是我们还是要防患于未然。

这种死锁是循环等待导致的，A 等待 B，B 等待 C，C 等待 A，构成一个回路。

死锁发生的原因

首先要回到锁的特性，因为锁是互斥的，一个线程拿到这个锁之后，另一个线程如果想要获得这个锁就必须阻塞等待。

锁是不可抢占的，不可剥夺的。 一个线程拿到这个锁之后，除非这个线程解锁释放这个锁，否则其他线程是无法暴力抢占获取的。

请求和保持。 这是发生在嵌套的情况下，也就是一个线程拿到 锁1 之后，在不释放锁 1 的前提下，申请获得锁 2 ，是有可能发生死锁的。
换一种说法就是，一个线程在获取到锁1 的时候，不想放弃这把锁1，也就是在保持锁 1 的情况下，发出锁 2 的请求。

循环等待。 多个线程，多把锁，在等待的过程中构成了循环，A 等待 B， B 也等待 A

解决死锁的办法

首先回顾第一个和第二个产生死锁的原因，我们直到这个是锁的基本性质引出的，所以我们无力回天，除非你自己写一个锁的设置。

破除嵌套

那我们来看一下第三个问题怎么解决，只要我们避免不要嵌套加锁就可以了，也就是用完锁 1 然后释放掉，最后再申请锁2 即可。

下面是死锁代码：

        Object locker1 = new Object();
        Object locker2 = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (locker1) {
                System.out.println("t1 线程获得了 锁1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker2) {
                    System.out.println("t1 线程成功获得了 锁2");
                }
            }
        });

        Thread t2 = new Thread(() -> {
           synchronized(locker2) {
               System.out.println("t2 线程获得了 锁2");
               synchronized(locker1) {
                   System.out.println("t2 线程成功获得了 锁1");
               }
           }
        });

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

下面的破除嵌套之后的代码：

    public static void main(String[] args) {
        Object locker1 = new Object();
        Object locker2 = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (locker1) {
                System.out.println("t1 线程获得了 锁1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            synchronized (locker2) {
                System.out.println("t1 线程成功获得了 锁2");
            }
        });

        Thread t2 = new Thread(() -> {
           synchronized(locker2) {
               System.out.println("t2 线程获得了 锁2");
           }
            synchronized(locker1) {
                System.out.println("t2 线程成功获得了 锁1");
            }
        });

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

运行成功，没有发生死锁问题。

破除循环等待

我们可以实现约定好加锁的顺序，就可以破除循环等待了。

例如，我们约定每个线程加锁的时候永远都是获得序号小的锁，然后获得序号大的锁。

原文链接:https://blog.csdn.net/liwuqianhzc/article/details/142959410