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

目录
相关文章
|
安全 算法 Java
Java 多线程:线程安全与同步控制的深度解析
本文介绍了 Java 多线程开发的关键技术,涵盖线程的创建与启动、线程安全问题及其解决方案,包括 synchronized 关键字、原子类和线程间通信机制。通过示例代码讲解了多线程编程中的常见问题与优化方法,帮助开发者提升程序性能与稳定性。
632 0
|
Java 测试技术 API
【JUC】(1)带你重新认识进程与线程!!让你深层次了解线程运行的睡眠与打断!!
JUC是什么?你可以说它就是研究Java方面的并发过程。本篇是JUC专栏的第一章!带你了解并行与并发、线程与程序、线程的启动与休眠、打断和等待!全是干货!快快快!
1394 2
|
JSON 网络协议 安全
【Java】(10)进程与线程的关系、Tread类;讲解基本线程安全、网络编程内容;JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念,进程是处于运行过程中的程序,并且具有一定的独立功能,进程是系统进行资源分配和调度的一个独立单位一般而言,进程包含如下三个特征。独立性动态性并发性。
714 1
|
JSON 网络协议 安全
【Java基础】(1)进程与线程的关系、Tread类;讲解基本线程安全、网络编程内容;JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念,进程是处于运行过程中的程序,并且具有一定的独立功能,进程是系统进行资源分配和调度的一个独立单位一般而言,进程包含如下三个特征。独立性动态性并发性。
645 1
|
Java 数据挖掘 调度
Java 多线程创建零基础入门新手指南:从零开始全面学习多线程创建方法
本文从零基础角度出发,深入浅出地讲解Java多线程的创建方式。内容涵盖继承`Thread`类、实现`Runnable`接口、使用`Callable`和`Future`接口以及线程池的创建与管理等核心知识点。通过代码示例与应用场景分析,帮助读者理解每种方式的特点及适用场景,理论结合实践,轻松掌握Java多线程编程 essentials。
975 5
|
数据采集 监控 调度
干货分享“用 多线程 爬取数据”:单线程 + 协程的效率反超 3 倍,这才是 Python 异步的正确打开方式
在 Python 爬虫中,多线程因 GIL 和切换开销效率低下,而协程通过用户态调度实现高并发,大幅提升爬取效率。本文详解协程原理、实战对比多线程性能,并提供最佳实践,助你掌握异步爬虫核心技术。
|
调度 开发工具 Android开发
【HarmonyOS Next】鸿蒙应用进程和线程详解
进程的定义: 进程是系统进行资源分配的基本单位,是操作系统结构的基础。 在鸿蒙系统中,一个应用下会有三类进程:
597 0
|
Linux 数据库 Perl
【YashanDB 知识库】如何避免 yasdb 进程被 Linux OOM Killer 杀掉
本文来自YashanDB官网,探讨Linux系统中OOM Killer对数据库服务器的影响及解决方法。当内存接近耗尽时,OOM Killer会杀死占用最多内存的进程,这可能导致数据库主进程被误杀。为避免此问题,可采取两种方法:一是在OS层面关闭OOM Killer,通过修改`/etc/sysctl.conf`文件并重启生效;二是豁免数据库进程,由数据库实例用户借助`sudo`权限调整`oom_score_adj`值。这些措施有助于保护数据库进程免受系统内存管理机制的影响。
|
Linux Shell
Linux 进程前台后台切换与作业控制
进程前台/后台切换及作业控制简介: 在 Shell 中,启动的程序默认为前台进程,会占用终端直到执行完毕。例如,执行 `./shella.sh` 时,终端会被占用。为避免不便,可将命令放到后台运行,如 `./shella.sh &`,此时终端命令行立即返回,可继续输入其他命令。 常用作业控制命令: - `fg %1`:将后台作业切换到前台。 - `Ctrl + Z`:暂停前台作业并放到后台。 - `bg %1`:让暂停的后台作业继续执行。 - `kill %1`:终止后台作业。 优先级调整:
1922 5
|
运维 关系型数据库 MySQL
掌握taskset:优化你的Linux进程,提升系统性能
在多核处理器成为现代计算标准的今天,运维人员和性能调优人员面临着如何有效利用这些处理能力的挑战。优化进程运行的位置不仅可以提高性能,还能更好地管理和分配系统资源。 其中,taskset命令是一个强大的工具,它允许管理员将进程绑定到特定的CPU核心,减少上下文切换的开销,从而提升整体效率。
掌握taskset:优化你的Linux进程,提升系统性能