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

简介: 多线程(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 进程负责回收该进程的资源 .

目录
相关文章
|
13天前
|
消息中间件 存储 缓存
【嵌入式软件工程师面经】Linux系统编程(线程进程)
【嵌入式软件工程师面经】Linux系统编程(线程进程)
25 1
|
2天前
|
分布式计算 JavaScript 前端开发
多线程、多进程、协程的概念、区别与联系
多线程、多进程、协程的概念、区别与联系
14 1
|
8天前
|
存储 网络协议 算法
【进程与线程】最好懂的讲解
【进程与线程】最好懂的讲解
16 1
聊聊python多线程与多进程
为什么要使用多进程与多线程呢? 因为我们如果按照流程一步步执行任务实在是太慢了,假如一个任务就是10秒,两个任务就是20秒,那100个任务呢?况且cpu这么贵,时间长了就是浪费生命啊!一个任务比喻成一个人,别个做高铁,你做绿皮火车,可想而知!接下来我们先看个例子:
|
4天前
|
数据挖掘 调度 开发者
Python并发编程的艺术:掌握线程、进程与协程的同步技巧
并发编程在Python中涵盖线程、进程和协程,用于优化IO操作和响应速度。`threading`模块支持线程,`multiprocessing`处理进程,而`asyncio`则用于协程。线程通过Lock和Condition Objects同步,进程使用Queue和Pipe通信。协程利用异步事件循环避免上下文切换。了解并发模型及同步技术是提升Python应用性能的关键。
21 5
|
3天前
|
Java 程序员
Java多线程编程是指在一个进程中创建并运行多个线程,每个线程执行不同的任务,并行地工作,以达到提高效率的目的
【6月更文挑战第18天】Java多线程提升效率,通过synchronized关键字、Lock接口和原子变量实现同步互斥。synchronized控制共享资源访问,基于对象内置锁。Lock接口提供更灵活的锁管理,需手动解锁。原子变量类(如AtomicInteger)支持无锁的原子操作,减少性能影响。
16 3
|
2天前
|
数据采集 自然语言处理 调度
【干货】python多进程和多线程谁更快
【干货】python多进程和多线程谁更快
10 2
|
7天前
|
消息中间件 分布式计算 物联网
深入理解操作系统之进程与线程管理
操作系统的核心职责之一是进程与线程管理,它关乎系统的效率和稳定性。本文将剖析进程与线程的基本概念、生命周期以及它们在现代操作系统中的实现机制。通过对比分析,我们将揭示进程与线程的区别、优势及其适用场景,并探讨它们对系统性能的具体影响。进一步,文章将讨论进程间通信(IPC)的几种方式,以及同步和异步处理在多任务环境中的重要性。最后,我们将展望未来操作系统在进程与线程管理方面可能的发展趋势。
|
12天前
|
安全 开发者 Python
Python中的多线程与多进程编程
Python作为一种广泛使用的编程语言,在处理并发性能时具有独特的优势。本文将深入探讨Python中的多线程与多进程编程技术,分析其原理和应用,帮助读者更好地理解并发编程在Python中的实现与优化。
|
13天前
|
消息中间件 安全 Java
【嵌入式软件工程师面经】Linux多进程与多线程
【嵌入式软件工程师面经】Linux多进程与多线程
13 1

相关实验场景

更多