并发编程之FutureTask.get()阻塞陷阱：深度解析线程池CPU飚高问题排查与解决方案

news2025/4/2 0:17:11

FutureTask.get方法阻塞陷阱：深度解析线程池CPU飚高问题排查与解决方法

  • FutureTask.get()方法阻塞陷阱：深度解析线程池CPU飚高问题排查与解决方法
    • 1、情景复现
      • 1.1 线程池工作原理
      • 1.2 业务场景模拟
      • 1.3 运行结果
      • 1.4 发现问题：线程池没有被关闭
      • 1.5 引发思考
    • 2、结合源码剖析 get 方法阻塞原因
      • 2.1 submit()方法提交任务
      • 2.2 FutureTask
        • 局部变量
        • 构造方法
        • FutureTask的run方法
        • FutureTask的get方法
        • FutureTask的get(timeout)方法
          • FutureTask的 awaitDone方法（核心）
        • FutureTask的report 方法
      • 2.3 解决方案

FutureTask.get()方法阻塞陷阱：深度解析线程池CPU飚高问题排查与解决方法

FutureTask的get()方法在多线程并发编程中应用场景还是蛮多的，作用是通过get方法阻塞直到获取到结果为止，而FutureTask一般是结合线程池来运行任务的，目的是由线程池统一管理和复用线程的资源。但是如果使用不当则会引发CPU飙升的问题? 接下来我们结合源码底层来剖析下到底会不会引发CPU飙升呢？

1、情景复现

1.1 线程池工作原理

在这里插入图片描述

1.2 业务场景模拟

结合上图线程池工作原理进行模拟场景：最大线程数为1，核心线程数为1，队列大小为1，也就是说当前线程池最多可以处理两个任务，如果大于两个任务，那么就会执行拒绝策略（注意此处是自定义拒绝策略，这里设置为打印日志，为FutureTask的get阻塞陷阱埋下伏笔）。

  • 自定义线程池配置
 ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                1, // 核心线程数为1
                1, // 最大线程数为1
                2, // 非核心线程不工作时，存活的时间 2s
                TimeUnit.SECONDS,// 非核心线程不工作时，存活时间对应的时间单位
                new ArrayBlockingQueue<>(1), // 阻塞队列 容量大小为1
                new RejectedExecutionHandler() { // 自定义拒绝策略
                    @Override
                    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                        System.out.println("====任务丢失啦啦啦===="); // 打印一行日志
                      // throw new RejectedExecutionException("任务丢失啦啦啦"); // 或抛出异常提示
                    }
                });
  • 提交任务执行
try {
            // 模拟任务执行
            List<Future<Integer>> futureList = Stream.of(2, 4, 6).map(num -> {
                System.out.println(Thread.currentThread().getName() + "<>>>>>> , 添加数字num(Begin):" + num);
                Future<Integer> future = poolExecutor.submit(() -> {
                    System.out.println(Thread.currentThread().getName() + ":=====任务开始执行=====Start!");
                    try {
                        // 模拟任务执行逻辑
                        TimeUnit.SECONDS.sleep(num);
                    } catch (InterruptedException e) {
                        System.out.println(Thread.currentThread().getName() + ">>任务被中断了，中断原因:" + e.getMessage());
                    }
                    System.out.println(Thread.currentThread().getName() + "=====任务执行完毕=====End!");
                    return num;
                });
                System.out.println(Thread.currentThread().getName() + "<>>>>>> , 添加数字num(End):" + num);
                return future;
            }).collect(Collectors.toList());

            // 获取任务执行结果
            for (Future<Integer> future : futureList) {
                try {
                    System.out.println(">>:" + future.get());
                } catch (InterruptedException | ExecutionException e) {
                    System.out.println("=====获取任务执行结果失败=====,原因:" + e.getMessage());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            poolExecutor.shutdown();
        }

1.3 运行结果

根据线程池的配置，最多处理的任务数量=最大线程数+阻塞队列 = 2，所以任务2和任务4会被处理，而任务6会根据拒绝策略输出一行日志。

在这里插入图片描述

1.4 发现问题：线程池没有被关闭

根据 1.3 输出的日志和运行结果截图分析可得：都是按照预想结果执行的，但问题是：为什么主线程任务为什么没有停止运行呢？因为业务逻辑使用了try…finally包裹，其中finally会关闭线程池的，按照正常执行逻辑是一定会关闭线程池的（因为我们代码中没有任何地方使用System.exit() 强制终止JVM）

在这里插入图片描述

结合以上运行截图可以发现，是由于拒绝策略中仅仅是打印了一行日志，导致FutureTask一直以为任务6还存活着，所以在调用futureTask的get方法时一直处于阻塞中，这是导致线程池没有关闭的直接原因。

1.5 引发思考

试想下，如果是在多线程环境下出现这种情况，那么线程池的CPU岂不是会持续飚高运行，从而直接影响服务器的处理性能（此时让我想到工作中有个万能公式：没有什么问题是重启解决不了的呢）。

既然我们已经清楚是因为 futureTask的get方法导致线程阻塞，下面我们继续结合源码来进行验证为什么会被阻塞？

2、结合源码剖析 get 方法阻塞原因

2.1 submit()方法提交任务

public <T> Future<T> submit(Callable<T> task) {
    // 若任务为空时，抛出空指针异常
    if (task == null) throw new NullPointerException();
    // 创建一个FutureTask对象
    RunnableFuture<T> ftask = newTaskFor(task);
    // 将该任务添加线程池中
    execute(ftask);
    // 返回FutureTask对象
    return ftask;
}
  • submit执行原理图
    在这里插入图片描述

2.2 FutureTask

在这里插入图片描述

局部变量
/**
 * Possible state transitions（可能的状态转换）:
   NEW -> COMPLETING -> NORMAL（业务逻辑执行正常时）
   NEW -> COMPLETING -> EXCEPTIONAL（业务逻辑执行异常时）
   NEW -> CANCELLED
   NEW -> INTERRUPTING -> INTERRUPTED
 */
private volatile int state; // 被volatile关键字修饰，确保线程可见
private static final int NEW          = 0; // 首次submit方法提交任务时，初始化值为NEW
private static final int COMPLETING   = 1; // 
private static final int NORMAL       = 2;
private static final int EXCEPTIONAL  = 3;
private static final int CANCELLED    = 4;
private static final int INTERRUPTING = 5;
private static final int INTERRUPTED  = 6;
构造方法
public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    this.callable = callable;
    this.state = NEW;       // ensure visibility of callable
}
FutureTask的run方法

如果业务逻辑call执行分为两种：1、执行异常（NEW -> COMPLETING -> EXCEPTIONAL）；2、正常执行（NEW -> COMPLETING -> NORMAL）

public void run() {
        // 若state不等于NEW 或 CAS 将期望值null设置为当前线程失败时，直接return
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
            // 当前state等于NEW 或 CAS占用为当前线程成功
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                // c代表当前Task，不等于空且state等于NEW
                V result;
                boolean ran;
                try {
                    // 执行Task的业务逻辑
                    result = c.call();
                    // task执行成功，则将ran变量设置为true
                    ran = true;
                } catch (Throwable ex) {
                    // 如果Task执行异常，则将结果result置为空，ran变量设置为false
                    result = null;
                    ran = false;
                    // 状态变更： NEW -> COMPLETING -> EXCEPTIONAL
                    setException(ex);
                }
                // ran变量为true时, 状态变更为：NEW -> COMPLETING -> NORMAL
                if (ran)
                    set(result);
            }
        } finally {

            runner = null;
            int s = state;

            // INTERRUPTING值等于5
            // 若state 大于或等于 5 ，此时state状态为 INTERRUPTING 或 INTERRUPTED
            if (s >= INTERRUPTING)
                // 如果 state等于INTERRUPTING(5)时，调用 Thread.yield() 方法，让出CPU的使用权
                // 当前线程状态由 运行状态(Running) 转化为 就绪状态(Runnable)。
                handlePossibleCancellationInterrupt(s);
        }
    }
FutureTask的get方法
public V get() throws InterruptedException, ExecutionException {
    int s = state; // 获取当前任务的 state 变量
    // 如果 state 变量的值 小于或等于 COMPLETING(1) 则进入 awaitDone (翻译为：等待完成)
    if (s <= COMPLETING)
        s = awaitDone(false, 0L);
    // 此处表示s 大于COMPLETING(1)
    return report(s);
}
FutureTask的get(timeout)方法
public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
    if (unit == null)
        throw new NullPointerException();
    int s = state;
    if (s <= COMPLETING &&
        (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
        throw new TimeoutException();// 超时会抛出异常TimeoutException
    return report(s);
}
FutureTask的 awaitDone方法（核心）
/**
 * <p>等待完成</p>
 * 根据 timed 参数分为两种情况：
 *     1、如果timed为true时，调用LockSupport.parkNanos(this, nanos);// 表示仅等待nanos时间
 *     2、如果timed为false时，则调用LockSupport.park(this); // 表示一直等待
 */
private int awaitDone(boolean timed, long nanos) throws InterruptedException {
    final long deadline = timed ? System.nanoTime() + nanos : 0L;
    WaitNode q = null;
    boolean queued = false;// 默认为false
    // 进入死循环
    for (;;) {
        // 当前线程被中断
        if (Thread.interrupted()) {
            // q不为空时移除waiter
            removeWaiter(q);
            // 抛出中断异常InterruptedException
            throw new InterruptedException();
        }

        // 表示当前线程未被中断
        int s = state;
        // 如果 state 大于 COMPLETING(1) 时，
        // 则代表此时的state值为NORMAL、EXCEPTIONAL、CANCELLED、INTERRUPTING、INTERRUPTED
        if (s > COMPLETING) {
            // waitNode不为空时，将thread置为null
            if (q != null)
                q.thread = null;
            // 返回当前的state值
            return s;
        }
        // 如果 state 值为COMPLETING时，则让出CPU的使用权
        else if (s == COMPLETING)
            Thread.yield();// 让出CPU的使用权
        else if (q == null)
            q = new WaitNode(); // 如果q等于空时，创建一个WaitNode节点
        else if (!queued)
            // 通过CAS（Compare-And-Swap）操作将当前线程的等待节点q插入到waiters链表中
            queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                 q.next = waiters, q);
        else if (timed) {
            // timed 为 true 时，调用LockSupport.parkNanos(this, nanos);
            nanos = deadline - System.nanoTime();
            if (nanos <= 0L) {
                // 如果小于或等于0，则表示等待时间到了
                removeWaiter(q);
                // 此时返回 state
                return state;
            }
            LockSupport.parkNanos(this, nanos);
        }
        else
            // 表示当前线程一直等待完成, 一直阻塞
            LockSupport.park(this);
    }
}
  • 引发阻塞的核心原因（LockSupport.park(this)）

如果使用的get(timeout)方法，则使用 LockSupport.parkNanos(this, nanos); 会阻塞 nanos 时间后会释放锁；反之使用 get()方法，则使用LockSupport.park(this); 会一直阻塞

FutureTask的report 方法
private V report(int s) throws ExecutionException {
    Object x = outcome;
    // 如果 state 变量 等于 NORMAL，则返回结果值 Value
    if (s == NORMAL)
        return (V)x;
    // state 大于或等于 CANCELLED，则state可能的值为：CANCELLED、INTERRUPTING、INTERRUPTED
    if (s >= CANCELLED) 
        throw new CancellationException();// 抛出异常
    // 抛出异常ExecutionException
    throw new ExecutionException((Throwable)x);
}

2.3 解决方案

在这里插入图片描述

重要事情讲三遍，注意、注意、注意：在使用get方法时首先需要结合线程池的拒绝策略，避免直接 使用get方法（导致线程一直阻塞中，进而引发服务器CPU飚高）。

综上所述是对FutureTask的get方法阻塞陷阱问题结合源码底层进行深度剖析，是我自己在工作中遇到的坑，如果你有用到这块知识，希望可以帮你避坑，当然如果有理解不到的地方望指正哟。

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2325023.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

在Ubuntu中固定USB设备的串口号

在Ubuntu中固定USB设备的串口号

获取设备信息 lsusb # 记录设备的Vendor ID和Product ID&#xff08;例如&#xff1a;ID 0403:6001&#xff09;# 获取详细属性&#xff08;替换X和Y为实际设备号&#xff09; udevadm info -a /dev/ttyUSBX 结果一般如下 创建udev规则文件 sudo gedit /etc/udev/rules.d/us…
阅读更多...
javaSE————文件IO（2）、

javaSE————文件IO（2）、

文件内容的读写——数据流 我们对于文件操作使用流对象Stream来操作&#xff0c;什么是流对象呢&#xff0c;水流是什么样的&#xff0c;想象一下&#xff0c;水流的流量是多种的&#xff0c;可以流100ml&#xff0c;也可以流1ml&#xff0c;流对象就和水流很像&#xff0c;我…
阅读更多...
前端常问的宏观“大”问题详解（二）

前端常问的宏观“大”问题详解（二）

JS与TS选型 一、为什么选择 TypeScript 而不是 JavaScript&#xff1f; 1. 静态类型系统&#xff1a;核心优势 TypeScript 的静态类型检查能在 编译阶段 捕获类型错误&#xff08;如变量类型不匹配、未定义属性等&#xff09;&#xff0c;显著减少运行时错误风险。例如&…
阅读更多...
智慧电力：点亮未来能源世界的钥匙

智慧电力：点亮未来能源世界的钥匙

在科技日新月异的今天&#xff0c;电力行业正经历着前所未有的变革。智慧电力&#xff0c;作为这一变革的核心驱动力&#xff0c;正逐步改变着我们对电力的认知和使用方式。它不仅是电力行业的一次技术革新&#xff0c;更是推动社会可持续发展、实现能源高效利用的重要途径。 智…
阅读更多...
架构师面试（二十三）：负载均衡

架构师面试（二十三）：负载均衡

问题 今天我们聊微服务相关的话题。 大中型微服务系统中&#xff0c;【负载均衡】是一个非常核心的组件&#xff1b;在微服务系统的不同位置对【负载均衡】进行了实现&#xff0c;下面说法正确的有哪几项&#xff1f; A. LVS 的负载均衡一般通过前置 F5 或是通过 VIP keepa…
阅读更多...
NSSCTF(MISC)—[justCTF 2020]pdf

NSSCTF(MISC)—[justCTF 2020]pdf

相应的做题地址&#xff1a;https://www.nssctf.cn/problem/920 binwalk分离 解压文件2AE59A.zip mutool 得到一张图片 B5F31内容 B5FFD内容 转换成图片 justCTF{BytesAreNotRealWakeUpSheeple}
阅读更多...
坚持“大客户战略”，昂瑞微深耕全球射频市场

坚持“大客户战略”，昂瑞微深耕全球射频市场

北京昂瑞微电子技术股份有限公司&#xff08;简称“昂瑞微”&#xff09;是一家聚焦射频与模拟芯片设计的高新技术企业。随着5G时代的全面到来&#xff0c;智能手机、智能汽车等终端设备对射频前端器件在通信频率、多频段支持、信道带宽及载波聚合等方面提出了更高需求&#xf…
阅读更多...
LiteDB 数据库优缺点分析与C#代码示例

LiteDB 数据库优缺点分析与C#代码示例

LiteDB 是一个轻量级的 .NET NoSQL 嵌入式数据库，完全用 C# 开发，支持跨平台（Windows、Linux、MacOS），并提供类似于 MongoDB 的简单 API。它以单文件形式存储数据，类似于 SQLite，支持事务和 ACID 特性，确保数据的一致性和可靠性。 优缺点分析 优点： 轻量级与嵌入式：…
阅读更多...
Linux系统中快速安装docker

Linux系统中快速安装docker

1 查看是否安装docker 要检查Ubuntu是否安装了Docker&#xff0c;可以使用以下几种方法&#xff1a; 方法1&#xff1a;使用 docker --version 命令 docker --version如果Docker已安装&#xff0c;输出会显示Docker的版本信息&#xff0c;例如&#xff1a; Docker version …
阅读更多...
CP15 协处理器

CP15 协处理器

ARMv7-A 一共支持 16 个协处理器&#xff0c;编号从 CP0~CP15。这里仅对CP15进行描述。 1、ARMv7-A 协处理器 ARMv7-A 处理器除了标准的 R0~R15&#xff0c;CPSR&#xff0c;SPSR 以外&#xff0c;由于引入了 MMU、TLB、Cache 等内容&#xff0c;ARMv7-A 使用协处理器来对这些…
阅读更多...
网络运维学习笔记（DeepSeek优化版）026 OSPF vlink（Virtual Link，虚链路)配置详解

网络运维学习笔记（DeepSeek优化版）026 OSPF vlink（Virtual Link，虚链路)配置详解

文章目录 OSPF vlink&#xff08;Virtual Link&#xff0c;虚链路)配置详解1. 虚链路核心特性2. 基础配置命令3. 状态验证命令3.1 查看虚链路状态3.2 验证LSDB更新 4. 关键技术要点4.1 路径选择机制4.2 虚链路的链路优化 5. 环路风险案例 OSPF vlink&#xff08;Virtual Link&a…
阅读更多...
【区块链安全 | 第十六篇】类型之值类型（三）

【区块链安全 | 第十六篇】类型之值类型（三）

文章目录 函数类型声明语法转换成员合约更新时的值稳定性示例 函数类型 函数类型是函数的类型。函数类型的变量可以通过函数进行赋值&#xff0c;函数类型的参数可以用来传递函数并返回函数。 函数类型有两种类型&#xff1a;内部函数和外部函数。 内部函数只能在当前合约内调…
阅读更多...
Kubernetes对象基础操作

Kubernetes对象基础操作

基础操作 文章目录 基础操作一、创建Kubernetes对象1.使用指令式命令创建Deployment2.使用指令式对象配置创建Deployment3.使用声明式对象配置创建Deployment 二、操作对象的标签1.为对象添加标签2.修改对象的标签3.删除对象标签4.操作具有指定标签的对象 三、操作名称空间四、…
阅读更多...
Java与代码审计-Java基础语法

Java与代码审计-Java基础语法

Java基础语法 package com.woniuxy.basic;public class HelloWorld {//入口函数public static void main(String[] args){System.out.println("Hello World");for(int i0;i< args.length;i){System.out.println(args[i]);}} }运行结果如下: 但是下面那个没有参数…
阅读更多...
Xenium | 细胞邻域(Cellular Neighborhood)分析(fixed radius)

Xenium | 细胞邻域(Cellular Neighborhood)分析(fixed radius)

上节我们介绍了空间转录组数据分析中常见的细胞邻域分析&#xff0c;CN计算过程中定义是否为细胞邻居的方法有两种&#xff0c;一种是上节我们使用固定K最近邻方法(fixed k-nearest neighbors)定义细胞Neighborhood&#xff0c;今天我们介绍另外一种固定半径范围内(fixed radiu…
阅读更多...
Python：爬虫概念与分类

Python：爬虫概念与分类

网络请求&#xff1a; https://www.baidu.com url——统一资源定位符 请求过程&#xff1a; 客户端&#xff0c;指web浏览器向服务器发送请求 请求&#xff1a;请求网址(request url)&#xff1b;请求方法(request methods)&#xff1b;请求头(request header)&…
阅读更多...
SQLMesh调度系统深度解析：内置调度与Airflow集成实践

SQLMesh调度系统深度解析：内置调度与Airflow集成实践

本文系统解析SQLMesh的两种核心调度方案&#xff1a;内置调度器与Apache Airflow集成。通过对比两者的适用场景、架构设计和操作流程&#xff0c;为企业构建可靠的数据分析流水线提供技术参考。重点内容包括&#xff1a; 内置调度器的轻量级部署与性能优化策略Airflow集成的端到…
阅读更多...
Multism TL494仿真异常

Multism TL494仿真异常

仿真模型如下&#xff1a;开关频率少了一半&#xff0c;而且带不动负载&#xff0c;有兄弟知道为什么吗 这里写自定义目录标题 欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题&#xff0c;有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码…
阅读更多...
HarmonyOS NEXT开发进阶（十五）：日志打印 hilog 与 console.log 的区别

HarmonyOS NEXT开发进阶（十五）：日志打印 hilog 与 console.log 的区别

文章目录 一、前言二、两者区别对比三、HiLog 详解四、拓展阅读 一、前言 在日常开发阶段&#xff0c;日志打印是调试程序非常常用的操作&#xff0c;在鸿蒙的官方文档中介绍了hilog这种方式&#xff0c;前端转过来的开发者发现console.log也可以进行日志打印&#xff0c;而且…
阅读更多...
vue 权限应用

vue 权限应用

目录 一、系统菜单栏权限 二、系统页面按钮权限 在企业开发中&#xff0c;不同的用户所扮演的角色不一样&#xff0c;角色拥有权限&#xff0c;所以用户拥有角色&#xff0c;就会有角色对应的权限。例如&#xff0c;张三是系统管理员角色&#xff0c;登录后就拥有整个系统的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023