一、什么是死锁
所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。
比如我和我朋友在吃饺子，我朋友吃饺子蘸醋，我吃饺子蘸辣椒。但我觉得吃饺子光蘸辣椒不过瘾，即蘸辣椒又蘸醋才过瘾。于是我对我朋友说：兄弟，你先把你面前的醋给我好吗？等我吃完了饺子，就把醋和辣椒都给你！！！但我这个时候也对我说：我也想即蘸醋又蘸辣椒，要不你先把你的东西给我，我吃完了饺子，再把醋和辣椒都给你！！！
于是我们就产生了争执，谁也不肯把对方想要的给对方，同时我们又都很执拗，如果不能做到同时即蘸醋又蘸辣椒，就不吃饺子。结果我们谁也吃不完饺子，于是也无法把对方所需要的醋或者辣椒给对方。
其中，我和朋友就相当于是两个进程，醋和辣椒就是两把锁。我和朋友都想同时即蘸醋又蘸辣椒（获取到对方的锁）然后再结束各自的进程，释放锁。但谁都不肯先释放锁，都等着对方释放锁，结果就是谁都无法正常的释放锁，都陷入了阻塞等待中，这也被称为死锁。
二、产生死锁的三个典型场景
🌰案例一（一个线程一把锁）
如果一个线程对同一把锁，连续加了两次锁，并且该锁还是不可重入锁的时候，就会产生死锁。
对可重入锁和不可重入锁的补充
如果同一个线程在重复获取同一把锁的过程中，形成了死锁。这把锁又被称为不可重入锁。而可重入锁的字面意思是“可以重新进入的锁”，即允许同一个线程多次获取同一把锁，不会出现死锁的情况。synchronized 是可重入锁
🌰案例二（两个线程两把锁）
package Thread2; import java.util.concurrent.*; import java.util.concurrent.locks.ReentrantLock; public class demo22 { private static Object locker1 = new Object(); // 相当于醋 private static Object locker2 = new Object(); // 相当于辣椒 public static void main(String[] args) { Thread t1 = new Thread(() -> { // t1线程相当于是我朋友，再有醋locker1的情况下，还想获取到我的辣椒locker2 synchronized (locker1) { System.out.println("我目前有醋，但我还想蘸辣椒"); try { Thread.sleep(1000); } catch (InterruptedException e) { // 正在和我交谈，想要获取辣椒 e.printStackTrace(); } synchronized (locker2) { System.out.println("获取辣椒成功！等我吃完饺子就把醋和辣椒都给对方！（释放锁）"); } } }); t1.start(); Thread t2 = new Thread(() -> { // t2线程相当于是我，再有辣椒locker2的情况下，还想获取到我朋友的醋locker1 synchronized (locker2) { System.out.println("我目前有辣椒，但我还想蘸醋"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (locker1) { System.out.println("获取醋成功！等我吃完饺子就把醋和辣椒都给对方！（释放锁）"); } } }); t2.start(); } }
死锁原因分析
// 死锁原因分析，线程t1给对象locker1加了锁，线程t2给对象locker2加了锁；
// 接着线程t1想要获取对象locker2的锁，但此时locker2被线程t2占用着，t1无法获取，陷入阻塞等待（也无法释放自己占用的对象locker1的锁）
// 几乎在同一时间，t2想要获取对象locker1的锁，但此时线程t1陷入阻塞，他所占用的locker1的锁无法正常释放。t2获取不到locker1的锁，t2无法正常工作，也无法正常释放自己占用的locker2的锁
// 就这样t1和t2陷入僵局，谁也无法正常释放锁，形成了死锁
解决办法
给我们的锁编号，按顺序来获取锁（规定都先蘸醋、接着蘸辣椒）
package Thread2; import java.util.concurrent.*; import java.util.concurrent.locks.ReentrantLock; public class demo22 { private static Object locker1 = new Object(); // 相当于醋 private static Object locker2 = new Object(); // 相当于辣椒 public static void main(String[] args) { Thread t1 = new Thread(() -> { // t1线程相当于是我朋友，一开始都有醋 synchronized (locker1) { System.out.println("我朋友说：我目前有醋，但我还想蘸辣椒"); try { Thread.sleep(1000); } catch (InterruptedException e) { // 正在和我交谈，想要获取辣椒 e.printStackTrace(); } synchronized (locker2) { System.out.println("我朋友说：获取辣椒成功！等我吃完饺子就把醋和辣椒都给对方！（释放锁）"); } } }); // 死锁的解决办法，多个线程在获取多个锁的时候，我们可以给这些锁编号。每个线程都按照锁的编号，从小到大的获取锁 // 一开始，我和我朋友要获取到的都是对象locker1的锁，产生竞争，竞争成功的获取到locker1的锁，失败的阻塞等待locker1锁的释放 // 竞争成功的接着又获取对象locker2的锁，此时因为另一个线程还在阻塞，没人和他竞争，直接获取locker2的锁，然后该线程结束，locker2锁、locker1锁按顺序释放 // 之前那个竞争失败的线程重写获取到locker1锁，接着又成功获取到locker2锁，最后线程结束，释放锁 t1.start(); Thread t2 = new Thread(() -> { // t2线程相当于是我，一开始都有醋 synchronized (locker1) { // 先获取编号为1的锁locker System.out.println("我说：目前有醋，但我还想蘸辣椒"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (locker2) { System.out.println("我说：获取辣椒成功！等我吃完饺子就把醋和辣椒都给对方！（释放锁）"); } } }); t2.start(); } }
🌰案例三（N个线程M把锁）
哲学家吃面条
5位哲学家围着一张桌子，桌子上有几碗面条。这5位哲学家的左右手两边各有一根筷子（注意是一根，不是一双，两根筷子才是一双，才能拿来吃面，一根筷子无法吃面）
5位哲学家相当于是5个线程，这些线程只有分别拿到左右手旁的两根筷子（各自要求的两把锁），才能完成进程，并释放自己所占用的锁。
然后呢，在某一时刻，哲学家都想吃面条：他们同时拿起了自己右手边的那根筷子。5位哲学家、5根筷子，他们每个人都只拿了一根筷子（获取到了一个锁） 。于是他们每个人都完成不了各自的进程，也无法释放他们所占用的锁（筷子），都吃不到面条。
这又是一个死锁问题
解决办法
那么怎么解决呢？和上面死锁的解决方案相同——我们要分析为什么会出现死锁，就是因为线程对锁的互相等待，线程一要获取的锁被线程二占用着，但同时线程二要获取的锁又被线程一占用着，于是他们两个都无法获取到完整的锁，无法完成各自的进程，并释放锁。都处于一个循环等待的过程。
要解决死锁问题，重点就是解决循环等待问题。如果每个线程都按一定的顺序来获取对应的锁，比如在上面的栗子中，我们给5根筷子（5把锁）按从1到5的顺序进行编号，哲学家只能拿到到左右两边锁编号最小的那把锁。（已经拿到的锁不用进行编号的比较）
按照这样的思路，这个死锁问题就可以得到解决
三、形成死锁的四个条件
从上述几个死锁的案例中我们也可以得到形成死锁的四个条件
互斥性：当多个线程对同一把锁，有竞争。在某一时刻，最终只有一个线程可以拥有这把锁
不可抢夺性：当一个线程已经获取到了锁A，其他线程要想获取锁A，这个时候只能等该线程把A释放了之后再获取，不能中途抢夺别的线程的锁。
请求和保持性：当一个线程获取到了锁A，除非该线程自己释放锁A，否则该线程就一直保持占有锁A
循环等待性：在死锁中往往会出现，线程A等着线程B释放锁，同时线程B又在等着线程A来释放他所占有的锁，结果A、B的锁都无法正常释放，也都无法完成各自的进程，陷入了一个循环等待的状态
只要这四个条件当中有一个条件被破坏，死锁问题就可以得到解决。其中循环等待性这个条件最容易被破坏——我们上面的对锁进行编号，来解决死锁问题。利用的就是对循环等待性的破坏。
