线程上下文切换与死锁

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. 小结

死锁是并发编程中最致命的问题，如何避免死锁，是并发编程中恒久不变的问题。
掌握死锁的实现以及如果避免死锁的发生，是本节内容的重中之重。