一、死锁是什么
死锁是这样的一种情形：多个同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。
【举个例子理解死锁】
张三李四两人去吃饺子，吃饺子需要酱油和醋。
张三抄起了酱油瓶， 李四抄起了醋瓶。
张三：你先把醋瓶给我，我用完了就把酱油瓶给你。
李四：你先把酱油瓶给我，我用完了就把醋瓶给你。
如果这俩人彼此之间互不相让，就构成了死锁。
酱油和醋相当于是两把锁，这两个人就是两个线程。
二、关于死锁的三种形式
-
一个线程，针对同一把锁连续加锁两次，如果是不可重入锁，就死锁了。
关于可重入锁：指的是一个线程连续针对一把锁，加锁了两次且不会出现死锁，满足这个要求就是可重入锁。 -
两个线程，两把锁（此时无论是不是不可重入锁，都会死锁）。
如：有两个线程 t1、t2，有两把锁 A、B
① t1 获取锁 A，t2 获取锁 B；
② t1 尝试获取锁 B，t2 尝试获取锁 A。
此时就会阻塞，产生死锁。
package Thread;
/**
* @Author : tipper
* @Description : 死锁的情况
*/
public class Demo4 {
//锁1
private static Object locker1 = new Object();
//锁2
private static Object locker2 = new Object();
public static void main(String[] args) {
//线程1
Thread t1 = new Thread(()->{
//加锁
synchronized (locker1) {
//此处的sleep很重要，要确保t1和t2都分别拿到一把锁之后。再进行后续动作。
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (locker2) {
System.out.println("t1 加锁成功！");
}
}
});
//线程2
Thread t2 = new Thread(()->{
//加锁
synchronized (locker2) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (locker1) {
System.out.println("t2 加锁成功！");
}
}
});
}
t1.start();
t2.start();
}
//输出为空且一直在执行
上述代码中，很明显什么都没打印，两个线程都没有获取成功第二把锁。
在此时，死锁代码中，两个 synchronized 是嵌套关系，不是并列关系，嵌套关系说明是在占用一把锁的前提下，获取另一把锁；而并列关系则是先释放前面的锁，再获取下一把锁，这样就不会死锁了。
-
N个线程，M把锁。（相当于第2种情况的扩充）
此时是更容易出现死锁的情况了。
一个经典的描述N个线程M把锁死锁的模型，哲学家就餐问题。
【哲学家就餐问题】
① 每个哲学家都会做两件事：思考人生，放下筷子 和 拿起左右两侧的两根筷子开始吃面条（先拿起左边，再拿起右边）；
② 哲学家什么时候吃面条和思考人生都是随机的；
③ 哲学家吃面条吃多久吃完也是随机的；
④ 哲学家吃面条的过程中，会有左右相邻的哲学家如果也想吃面条，就要阻塞等待。
基于上述规则，通常情况下，整个系统可以良好运转，但是极端情况下会出现问题！
比如，同一时刻，五个哲学家都想吃面条，同时拿起左手的筷子，然后再尝试拿右手的筷子，就会发现右手的筷子都被占用了，哲学家们互不相让，这个时候就形成了死锁。
死锁是一种严重的BUG！会导致程序的线程“卡死”，无法正常工作！
三、如何避免死锁
死锁产生的四个必要条件：
- 互斥使用（锁的基本特性）：当一个线程持有一把锁之后，另一个线程想要取得锁，就要阻塞等待；
- 不可抢占（锁的基本特性）：资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。（当锁已经被 线程1 拿到之后，线程2 只能等 线程1 主动释放，不能强行抢过来）
- 请求和保持（代码结构）：当资源请求者在请求其他的资源的同时保持对原有资源的占有。（一个线程尝试获取多把锁，先拿到 锁1 之后，再尝试获取 锁2，获取的时候，锁1 不会释放）。
- 循环等待：即存在一个等待队列，P1占有P2的资源，P2占有P3的资源，P3占有P1的资源，等待的依赖关系，这样就形成了一个等待环路。
当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。
其中最容易破坏的就是“循环等待”。“互斥使用”、“不可抢占”是锁本身的特性，破坏不了，对于“请求保持”来说，调整代码结构，避免编写“锁嵌套”逻辑。这个方案不一定好用，有的需求可能就是需要进行这种，获取多个锁再操作。
【破坏循环等待】
最常用的一种死锁组织技术就是锁排序。约定加锁的顺序，就可以避免循环等待。
假设有 N 个线程尝试获取 M 把锁，就可以针对 M 把锁进行编号(1，2，3…M)。
N 个线程尝试获取锁的时候，都按照固定的按编号由小到大顺序来获取锁。这样就可以避免环路等待。
比如：哲学家就餐问题，约定每个哲学家都是先拿起编号小的筷子，后拿起编号大的筷子，此时循环等待就破除了，上述系统就不会再出现死锁了。
【可能产生环路等待的代码】
两个线程对于加锁的顺序没有约定，就容易产生环路等待。文章来源：https://www.toymoban.com/news/detail-824088.html
package Thread;
public class Demo4 {
//锁1
private static Object locker1 = new Object();
//锁2
private static Object locker2 = new Object();
public static void main(String[] args) {
//线程1
Thread t1 = new Thread(()->{
//加锁
synchronized (locker1) {
//此处的sleep很重要，要确保t1和t2都分别拿到一把锁之后。再进行后续动作。
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
synchronized (locker2) {
System.out.println("t1 加锁成功！");
}
//线程2
Thread t2 = new Thread(()->{
//加锁
synchronized (locker2) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
synchronized (locker1) {
System.out.println("t2 加锁成功！");
}
}
}
//运行结果：
此时一直运行
【不会产生环路等待的代码】
约定号先获取 locker1，再获取 locker2，就不会环路等待。文章来源地址https://www.toymoban.com/news/detail-824088.html
package Thread;
/**
* @Author : tipper
* @Description : 死锁的情况
*/
public class Demo4 {
//锁1
private static Object locker1 = new Object();
//锁2
private static Object locker2 = new Object();
public static void main(String[] args) {
//线程1
Thread t1 = new Thread(()->{
//加锁
synchronized (locker1) {
//此处的sleep很重要，要确保t1和t2都分别拿到一把锁之后。再进行后续动作。
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (locker2) {
System.out.println("t1 加锁成功！");
}
}
});
//线程2
Thread t2 = new Thread(()->{
//加锁
synchronized (locker1) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (locker2) {
System.out.println("t2 加锁成功！");
}
}
});
t1.start();
t2.start();
}
}
//运行结果：
t1 加锁成功！
t2 加锁成功！
到了这里，关于JavaEE之多线程编程：5. 死锁（详解！！！）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
