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

目录
相关文章
|
6天前
|
Java Linux 调度
硬核揭秘:线程与进程的底层原理,面试高分必备!
嘿,大家好!我是小米,29岁的技术爱好者。今天来聊聊线程和进程的区别。进程是操作系统中运行的程序实例,有独立内存空间;线程是进程内的最小执行单元,共享内存。创建进程开销大但更安全,线程轻量高效但易引发数据竞争。面试时可强调:进程是资源分配单位,线程是CPU调度单位。根据不同场景选择合适的并发模型,如高并发用线程池。希望这篇文章能帮你更好地理解并回答面试中的相关问题,祝你早日拿下心仪的offer!
25 6
|
28天前
|
NoSQL Redis
单线程传奇Redis,为何引入多线程?
Redis 4.0 引入多线程支持,主要用于后台对象删除、处理阻塞命令和网络 I/O 等操作,以提高并发性和性能。尽管如此,Redis 仍保留单线程执行模型处理客户端请求,确保高效性和简单性。多线程仅用于优化后台任务,如异步删除过期对象和分担读写操作,从而提升整体性能。
61 1
|
1月前
|
调度 开发者
深入理解:进程与线程的本质差异
在操作系统和计算机编程领域,进程和线程是两个核心概念。它们在程序执行和资源管理中扮演着至关重要的角色。本文将深入探讨进程与线程的区别,并分析它们在现代软件开发中的应用和重要性。
68 5
|
1月前
|
调度 开发者
核心概念解析:进程与线程的对比分析
在操作系统和计算机编程领域,进程和线程是两个基本而核心的概念。它们是程序执行和资源管理的基础,但它们之间存在显著的差异。本文将深入探讨进程与线程的区别,并分析它们在现代软件开发中的应用和重要性。
65 4
|
2月前
|
并行计算 数据处理 调度
Python中的并发编程:探索多线程与多进程的奥秘####
本文深入探讨了Python中并发编程的两种主要方式——多线程与多进程,通过对比分析它们的工作原理、适用场景及性能差异,揭示了在不同应用需求下如何合理选择并发模型。文章首先简述了并发编程的基本概念,随后详细阐述了Python中多线程与多进程的实现机制,包括GIL(全局解释器锁)对多线程的影响以及多进程的独立内存空间特性。最后,通过实例演示了如何在Python项目中有效利用多线程和多进程提升程序性能。 ####
|
3月前
|
Java 开发者
在Java多线程编程中,选择合适的线程创建方法至关重要
【10月更文挑战第20天】在Java多线程编程中,选择合适的线程创建方法至关重要。本文通过案例分析,探讨了继承Thread类和实现Runnable接口两种方法的优缺点及适用场景,帮助开发者做出明智的选择。
34 2
|
3月前
|
Java
Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口
【10月更文挑战第20天】《JAVA多线程深度解析:线程的创建之路》介绍了Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口。文章详细讲解了每种方式的实现方法、优缺点及适用场景,帮助读者更好地理解和掌握多线程编程技术,为复杂任务的高效处理奠定基础。
55 2
|
2月前
|
数据采集 Java Python
爬取小说资源的Python实践:从单线程到多线程的效率飞跃
本文介绍了一种使用Python从笔趣阁网站爬取小说内容的方法,并通过引入多线程技术大幅提高了下载效率。文章首先概述了环境准备,包括所需安装的库,然后详细描述了爬虫程序的设计与实现过程,包括发送HTTP请求、解析HTML文档、提取章节链接及多线程下载等步骤。最后,强调了性能优化的重要性,并提醒读者遵守相关法律法规。
82 0
|
8月前
|
存储 Java
高并发编程之多线程锁和Callable&Future 接口
高并发编程之多线程锁和Callable&Future 接口
100 1
|
5月前
|
并行计算 Java 大数据
Callable和Future
Callable和Future

热门文章

最新文章

相关实验场景

更多