共计 4939 个字符，预计需要花费 13 分钟才能阅读完成。
本文首发自 [慕课网]（imooc.com），想理解更多 IT 干货内容，程序员圈内热闻，欢送关注 ” 慕课网 ” 及“慕课网公众号”！
作者：王军伟 Tech| 慕课网讲师
1. 前言
本节内容次要是对死锁进行深刻的解说，具体内容点如下：
了解线程的上下文切换，这是本节的辅助根底内容，从概念层面进行了解即可；
理解什么是线程死锁，在并发编程中，线程死锁是一个致命的谬误，死锁的概念是本节的重点之一；
理解线程死锁的必备 4 因素，这是防止死锁的前提，理解死锁的必备因素，能力找到防止死锁的形式；
把握死锁的实现，通过代码实例，进行死锁的实现，深刻领会什么是死锁，这是本节的重难点之一；
把握如何防止线程死锁，咱们可能实现死锁，也能够防止死锁，这是本节内容的外围。
2. 了解线程的上下文切换
概述： 在多线程编程中，线程个数个别都大于 CPU 个数，而每个 CPU 同一时-刻只能被一个线程应用，为了让用户感觉多个线程是在同时执行的，CPU 资源的调配采纳了工夫片轮转的策略，也就是给每个线程调配一个工夫片，线程在工夫片内占用 CPU 执行工作。
定义： 以后线程应用完工夫片后，就会处于就绪状态并让出 CPU，让其余线程占用，这就是上下文切换，从以后线程的上下文切换到了其余线程。
问题点解析： 那么就有一个问题，让出 CPU 的线程等下次轮到本人占有 CPU 时如何晓得本人之前运行到哪里了？所以在切换线程上下文时须要保留以后线程的执行现场，当再次执行时依据保留的执行现场信息复原执行现场。
线程上下文切换机会： 以后线程的 CPU 工夫片应用完或者是以后线程被其余线程中断时，以后线程就会开释执行权。那么此时执行权就会被切换给其余的线程进行工作的执行，一个线程开释，另外一个线程获取，就是咱们所说的上下文切换机会。
3. 什么是线程死锁
定义：死锁是指两个或两个以上的线程在执行过程中，因抢夺资源而造成的相互期待的景象，在无外力作用的状况下，这些线程会始终互相期待而无奈持续运行上来。
如上图所示死锁状态，线程 A 己经持有了资源 2，它同时还想申请资源 1，可是此时线程 B 曾经持有了资源 1，线程 A 只能期待。
反观线程 B 持有了资源 1，它同时还想申请资源 2，然而资源 2 曾经被线程 A 持有，线程 B 只能期待。所以线程 A 和线程 B 就因为互相期待对方曾经持有的资源，而进入了死锁状态。
4. 线程死锁的必备因素
互斥条件 ：过程要求对所调配的资源进行排他性管制，即在一段时间内某资源仅为一个过程所占有。此时若有其余过程申请该资源，则申请过程只能期待；
不可剥夺条件 ：过程所取得的资源在未应用结束之前，不能被其余过程强行夺走，即只能由取得该资源的过程本人来开释（只能是被动开释，如 yield 开释 CPU 执行权)；
申请与放弃条件 ：过程曾经放弃了至多一个资源，但又提出了新的资源申请，而该资源已被其余过程占有，此时申请过程被阻塞，但对本人已取得的资源放弃不放；
循环期待条件：指在产生死锁时，必然存在一个线程申请资源的环形链，即线程汇合 {T0,T1,T2,…Tn}中的 T0 正在期待一个 T1 占用的资源，T1 正在期待 T2 占用的资源，以此类推，Tn 正在期待己被 T0 占用的资源。
如下图所示：
5. 死锁的实现
为了更好的理解死锁是如何产生的，咱们首先来设计一个死锁抢夺资源的场景。
场景设计：
- 创立 2 个线程，线程名别离为 threadA 和 threadB；
- 创立两个资源，应用 new Object () 创立即可，别离命名为 resourceA 和 resourceB；
- threadA 持有 resourceA 并申请资源 resourceB；
- threadB 持有 resourceB 并申请资源 resourceA；
- 为了确保产生死锁景象，请应用 sleep 办法发明该场景；
- 执行代码，看是否会产生死锁。
冀望后果：产生死锁，线程 threadA 和 threadB 相互期待。
Tips：此处的试验会应用到关键字 synchronized，后续大节还会对关键字 synchronized 独自进行深刻解说，此处对 synchronized 的应用仅仅为高级应用，有 JavaSE 根底即可。实例：
public class DemoTest{private static Object resourceA = new Object();// 创立资源 resourceA
private static Object resourceB = new Object();// 创立资源 resourceB
public static void main(String[] args) throws InterruptedException {
// 创立线程 threadA
Thread threadA = new Thread(new Runnable() {
@Override
public void run() {synchronized (resourceA) {System.out.println(Thread.currentThread().getName() + "获取 resourceA。");
try {Thread.sleep(1000); // sleep 1000 毫秒，确保此时 resourceB 曾经进入 run 办法的同步模块
} catch (InterruptedException e) {e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "开始申请 resourceB。");
synchronized (resourceB) {System.out.println (Thread.currentThread().getName() + "获取 resourceB。");
}
}
}
});
threadA.setName("threadA");
// 创立线程 threadB
Thread threadB = new Thread(new Runnable() { // 创立线程 1
@Override
public void run() {synchronized (resourceB) {System.out.println(Thread.currentThread().getName() + "获取 resourceB。");
try {Thread.sleep(1000); // sleep 1000 毫秒，确保此时 resourceA 曾经进入 run 办法的同步模块
} catch (InterruptedException e) {e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "开始申请 resourceA。");
synchronized (resourceA) {System.out.println (Thread.currentThread().getName() + "获取 resourceA。");
}
}
}
});
threadB.setName("threadB");
threadA. start();
threadB. start();}
}
代码解说：
- 从代码中来看，咱们首先创立了两个资源 resourceA 和 resourceB；
- 而后创立了两条线程 threadA 和 threadB。threadA 首先获取了 resourceA，获取的形式是代码 synchronized (resourceA)，而后沉睡 1000 毫秒；
- 在 threadA 沉睡过程中，threadB 获取了 resourceB，而后使本人沉睡 1000 毫秒；
- 当两个线程都昏迷时，此时能够确定 threadA 获取了 resourceA，threadB 获取了 resourceB，这就达到了咱们做的第一步，线程别离持有本人的资源；
- 那么第二步就是开始申请资源，threadA 申请资源 resourceB，threadB 申请资源 resourceA 无奈 resourceA 和 resourceB 都被各自线程持有，两个线程均无奈申请胜利，最终达成死锁状态。
执行后果验证：
threadA 获取 resourceA。threadB 获取 resourceB。threadA 开始申请 resourceB。threadB 开始申请 resourceA。看下验证后果，发现曾经呈现死锁，threadA 申请 resourceB，threadB 申请 resourceA，但均无奈申请胜利，死锁得以试验胜利。
6. 如何防止线程死锁
要想防止死锁，只须要毁坏掉至多一个结构死锁的必要条件即可，学过操作系统的读者应该都晓得，目前只有申请并持有和环路期待条件是能够被毁坏的。
造成死锁的起因其实和申请资源的程序有很大关系，应用资源申请的有序性准则就可防止死锁。
咱们仍然以第 5 个知识点进行解说，那么试验的需要和场景不变，咱们仅仅对之前的 threadB 的代码做如下批改，以防止死锁。
代码批改：
Thread threadB = new Thread(new Runnable() { // 创立线程 1
@Override
public void run() {synchronized (resourceA) { // 批改点 1
System.out.println(Thread.currentThread().getName() + "获取 resourceB。");// 批改点 3
try {Thread.sleep(1000); // sleep 1000 毫秒，确保此时 resourceA 曾经进入 run 办法的同步模块
} catch (InterruptedException e) {e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "开始申请 resourceA。");// 批改点 4
synchronized (resourceB) { // 批改点 2
System.out.println (Thread.currentThread().getName() + "获取 resourceA。"); // 批改点 5
}
}
}
});
请看如上代码示例，有 5 个批改点：
- 批改点 1：将 resourceB 批改成 resourceA；
- 批改点 2：将 resourceA 批改成 resourceB；
- 批改点 3：将 resourceB 批改成 resourceA；
- 批改点 4：将 resourceA 批改成 resourceB；
- 批改点 5：将 resourceA 批改成 resourceB。
请读者按批示批改代码，并从新运行验证。
批改后代码解说：
- 从代码中来看，咱们首先创立了两个资源 resourceA 和 resourceB；
- 而后创立了两条线程 threadA 和 threadB。threadA 首先获取了 resourceA，获取的形式是代码 synchronized (resourceA)，而后沉睡 1000 毫秒；
- 在 threadA 沉睡过程中，threadB 想要获取 resourceA，然而 resourceA 目前正被沉睡的 threadA 持有，所以 threadB 期待 threadA 开释 resourceA；
- 1000 毫秒后，threadA 昏迷了，开释了 resourceA，此时期待的 threadB 获取到了 resourceA，而后 threadB 使本人沉睡 1000 毫秒；
- threadB 沉睡过程中，threadA 申请 resourceB 胜利，继续执行胜利后，开释 resourceB；
- 1000 毫秒后，threadB 昏迷了，继续执行获取 resourceB，执行胜利。
执行后果验证：
threadA 获取 resourceA。threadA 开始申请 resourceB。threadA 获取 resourceB。threadB 获取 resourceA。threadB 开始申请 resourceB。threadB 获取 resourceB。咱们发现 threadA 和 threadB 依照雷同的程序对 resourceA 和 resourceB 顺次进行拜访，防止了相互穿插持有期待的状态，防止了死锁的产生。
7. 小结
死锁是并发编程中最致命的问题，如何防止死锁，是并发编程中恒久不变的问题。
把握死锁的实现以及如果防止死锁的产生，是本文内容的重中之重。
欢送关注「慕课网」官网帐号，咱们会始终保持提供 IT 圈优质内容，分享干货常识，大家一起独特成长吧！
本文原创公布于慕课网，转载请注明出处，谢谢合作