多线程(CAS, ABA问题, Runnable & Callable & 僵尸线程 & 孤儿进程)

CAS (Compare And Swap)

比较并交换, 可以理解成是 CPU 提供一种特殊指令, 该指令是原子的, 可以用其一定程度解决线程安全问题, 具体过程如下

假设内存中有原数据 V, 寄存器中有旧的预期值 A 和修改值 B

1. 比较 V 与 B 的值是否相等
2. 如果相等, 则将 B 写入 V
3. 返回操作是否成功

上述三步操作就是 CAS 的具体描述, 并且这三步操作是通过一条 CPU 指令完成 (原子操作)

简单理解

CAS 即 Compare And Swap , “比较和交换”. 相当于通过一个原子操作, 同时完成 “读取内存, 比较是否相等, 修改内存” 这三个步骤, 本质上需要 CPU 指令的支撑 .

CAS 的应用场景

1. 实现原子类

Java 标准库提供了一些原子类 java.util.concurrent.atomic

而这些原子类基于 CAS 实现, 使用原子类进行多线程的操作, 可保证线程安全

2. 实现自旋锁

基于 CAS 实现的锁, 具有更强的锁竞争能力

下述是一段CAS 实现自旋锁的伪代码(基本逻辑是这样, 但是实现要复杂的多)

伪代码分析

可以看到, 如果把解锁操作认为是给锁对象赋值 null 的话,加锁操作就是在一个死循环内不断的去对锁资源进行判定, 看其是否已被释放, 当其被释放的时候, 就可以被当前线程获取.

伪代码是在 while() 循环内进行, 代表此时 CPU 一直在使用

ABA问题

什么是ABA问题

假设存在两个线程 t1 和 t2, 存在共享变量为 num, 初始值为 A.

接下来, 线程 t1 想使用 CAS 把 num 值改成 Z, 那么就需要

• 先读取 num 的值, 记录到 oldNum 变量中

• 使用 CAS 判定 num 的值是否等于 oldNum, 如果相等, 那么将Z写入num

那么如果在这两个步骤之间, t2线程对 num 进行了操作, 把 num 的值从 A 改成了 B, 又从 B 改成了 A.

对于 线程 t1来说, A->B->A 的变换不可见, 但是仍会进行第二步操作, 即 num : A -> Z, 这就是 ABA问题: CAS 的误判

解决方案

给要修改的数据引入版本号

在 CAS 比较数据的当前值和旧值的同时, 也比较版本号是否符合预期.

• CAS 操作在读取旧值的同时, 也读取版本号

• 真正修改的时候

• 如果当前读到的版本号和之前读到的版本号相同, 则修改数据, 并把版本号+1
• 如果当前读到的版本号和之前读到的版本号不同,则操作失败(认为数据已经被修改过了)

Runnable 和 Callable

• 二者均是 interface, 描述了一个任务
• Runnable 描述的是不带返回值的任务
Callable 描述的是带返回值的任务

• Callable 接口实现类中的 run() 方法允许向上抛出, 也可在内部处理 (try catch)
Runnable 接口实现类中 run() 方法的异常必须在内部处理, 不能抛出

Callable 通常搭配 FutureTask 来使用. FutureTask 用来保存 Callable 的返回结果. 因为 Callable 通常是在另一个线程中执行的, 啥时候执行完不确定.

FutureTask 就可以负责等待获取这个 “未来的” 结果

Runnable 和 Callable 使用对比

创建线程 计算 1+2+3+ … +100000

Runnable 版本

// Runnable 借助外部资源来实现结果返回
public class Main {
    static class Result{
        public int sum = 0;
        public Object lock = new Object();
    }
    public static void main(String[] args) throws InterruptedException {
        Result result = new Result();

        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                int sum = 0;
                for (int i = 1; i <= 10000; i++) {
                    sum += i;
                }
                synchronized (result.lock) {
                    result.sum = sum;
                    result.lock.notify();
                }
            }
        });
        t.start();

        synchronized (result.lock) {  // 获取锁对象
          // 这个 while 是为了让 print 语句在子线程之后运行 
          // 也可以使用 t.join(); 
            while(result.sum == 0){
                result.lock.wait(); 
            }
            
            System.out.println("sum: " + result.sum);
        }
    }
}

运行结果

Callable 版本

// Callable 借助 FutureTask 获取进程运行结果
public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum =0 ;
                for (int i = 0; i < 10000; i++) {
                    sum+=i;
                }
                return sum;
            }
        };
        // 将 Callable 任务用 FutureTask 再封装一层
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        // 创建进程执行任务
        Thread t = new Thread(futureTask);
        t.start();

        // 使用 FutureTask.get() 获取 Callable 的运行结果
        // 该方法会阻塞, 直到对应的线程执行结束, 获取到返回结果
        System.out.println(futureTask.get());
    }
}

运行结果

对比

• Runnable 获取线程的运行结果需要借助外部资源, 而且涉及线程安全问题.
• Callable 可以更方便的获取线程运行结果, 并且 FutureTask 的阻塞功能也减少线程同步代码的书写.

僵尸进程: 子进程先于父进程结束, 并且父进程无暇回收子进程资源, 此时子线程残留资源 (eg: PCB) 存放于内核中, 就变成了僵尸进程

孤儿进程: 父进程先于子进程结束, 此时子进程会变成孤儿进程. 孤儿进程由 init 进程 (通常是编号为 0 的进程) 领养, 并由 init 进程完成状态收集工作

杀死僵尸进程 : 杀死其父进程即可. 此时僵尸进程就变成了孤儿进程, 会被 init 进程领养, init 进程负责回收该进程的资源 .