Java 多线程-3 FutureTask学习

于 2024-07-09 09:56:26 发布
阅读量563 收藏 7
点赞数 7
文章标签： java 学习 android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45149567/article/details/140287262
版权

一. FutureTask的继承体系

FutureTask 实现了 Runnable 接口和 Future 接口；

FutureTask 也是一个 Runnable 对象；

在这里插入图片描述

二. 使用案例

1. 通过Callable构造出FutureTask

通过 callable 对象创建出 FutureTask 对象，实例如下：

/**
 * 通过 callable 对象创建出 FutureTask 对象
 */
public static void main(String[] args) {

    // 创建一个 Callable 对象
    Callable<Integer> callable = new Callable<>() {
        @Override
        public Integer call() throws Exception {
            TimeUnit.SECONDS.sleep(2);
            int sum = 0;
            for (int i = 0; i < 100; i++) {
                sum = sum + i;
            }
            return sum;
        }
    };

    // 使用 Callable 创建 FutureTask
    FutureTask<Integer> futureTask = new FutureTask<>(callable);

    // 创建一个线程执行 futureTask
    Thread thread = new Thread(futureTask);
    thread.start();

    System.out.println("获取异步任务结果");
    Integer result = null;
    try {
        // 获取异步任务结果，当前主线程会阻塞在这个 get() 中
        result = futureTask.get();
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("result: " + result);
}

打印如下：

获取异步任务结果
result: 4950

2. 通过Runnable构造出FutureTask

通过 runnable 对象创建出 FutureTask 对象，示例如下：

/**
 * 通过 runnable 对象创建出 FutureTask 对象
 */
public static void main(String[] args) {

    // 创建一个 Runnable 对象
    Runnable runnable = new Runnable() {
        @SneakyThrows
        @Override
        public void run() {
            TimeUnit.SECONDS.sleep(2);
        }
    };

    // 使用 Callable 创建 FutureTask
    FutureTask<Integer> futureTask = new FutureTask<>(runnable, null);

    // 创建一个线程执行 futureTask
    Thread thread = new Thread(futureTask);
    thread.start();

    System.out.println("获取异步任务结果");
    Integer result = null;
    try {
        // 获取异步任务结果
        result = futureTask.get();
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("result: " + result);
}

打印如下：

获取异步任务结果
result: null

3. FutureTask.get()设置超时时间

FutureTask.get()设置超时时间，当指定的超时时间到的时候任务还未执行完成，会抛出 TimeoutException；

/**
 * FutureTask.get() 设置超时时间
 */
public static void main(String[] args) {

    // 创建一个 Callable 对象
    Callable<Integer> callable = new Callable<>() {
        @Override
        public Integer call() throws Exception {
            TimeUnit.SECONDS.sleep(2);
            int sum = 0;
            for (int i = 0; i < 100; i++) {
                sum = sum + i;
            }
            return sum;
        }
    };

    // 使用 Callable 创建 FutureTask
    FutureTask<Integer> futureTask = new FutureTask<>(callable);

    // 创建一个线程执行 futureTask
    Thread thread = new Thread(futureTask);
    thread.start();

    System.out.println("获取异步任务结果");
    Integer result = null;
    try {
        // 获取异步任务结果，超时时间为 1 秒
        // 当 1 秒到的时候任务还未执行完成，会抛出 TimeoutException
        result = futureTask.get(1, TimeUnit.SECONDS);
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("result: " + result);
}

打印如下：

获取异步任务结果
java.util.concurrent.TimeoutException
	at java.base/java.util.concurrent.FutureTask.get(FutureTask.java:204)
	at com.zengqiang.futuretask.Test03.main(Test03.java:48)
result: null

三. 源码分析

1. 属性分析

我们看下 FutureTask 的几个重要属性；

/**
 * 表示当前 task 状态，注意是当前任务的状态，不是线程的状态！
 * 任务的状态转换情况如下：
 * 	NEW -> COMPLETING -> NORMAL
 * 	NEW -> COMPLETING -> EXCEPTIONAL
 * 	NEW -> CANCELLED
 * 	NEW -> INTERRUPTING -> INTERRUPTED
 */
private volatile int state;


// 当前任务尚未执行
private static final int NEW          = 0;
// 当前任务正在结束，尚未完全结束，一种临界状态
private static final int COMPLETING   = 1;
// 当前任务正常结束
private static final int NORMAL       = 2;
// 当前任务执行过程中发生了异常：内部封装的 callable.run() 抛出了异常
private static final int EXCEPTIONAL  = 3;
// 当前任务被取消
private static final int CANCELLED    = 4;
// 当前任务中断中..
private static final int INTERRUPTING = 5;
// 当前任务已中断
private static final int INTERRUPTED  = 6;


// 可以看到 FutureTask 中的任务是以 Callable 的方式存在的
private Callable<V> callable;


// 正常情况下：任务正常执行结束，outcome 保存执行结果，也就是 callable 的返回值
// 非正常情况：callable 抛出了异常，outcome 保存异常对象
private Object outcome;


// 当前执行该任务的线程
private volatile Thread runner;


// 会有很多线程执行 futureTask.get() 去获取当前任务的结果，如果当前任务还未完成，这些线程会阻塞住
// 这个 waiters 其实就是一个链表，将线程包装成 WaitNode 链表并阻塞挂起
private volatile WaitNode waiters;

简单看下 WaitNode 类，可以看到就是维护了一个线程等待节点链表；

static final class WaitNode {
    volatile Thread thread;
    volatile WaitNode next;
    WaitNode() { thread = Thread.currentThread(); }
}

2. 两种构造方法

2.1 传参为Callable

传参为 Callable 对象的情况，直接给 FutureTask 的 callable 赋值，当前任务状态为 NEW；

public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    
    // callable 就是我们自己的任务对象，直接设置给 FutureTask 的 callable 属性
    this.callable = callable;
    
    // 设置当前任务状态为 NEW
    this.state = NEW;
}

2.2 传参为Runnable, result

传参为 Runnable 对象和 result，会将其包装为一个 Callable 对象；

public FutureTask(Runnable runnable, V result) {
    
    // 将 Runnable 和 result 转换为 callable 对象
    this.callable = Executors.callable(runnable, result);
    
    //设置当前任务状态为 NEW
    this.state = NEW;       
}

可以看到，FutureTask 把 runnable 和 result 包装为了 Callable 对象；

// --------------------------------- Executors -----------------------------------
public static <T> Callable<T> callable(Runnable task, T result) {
    // 返回的是 RunnableAdater 适配器类，该类实现了 Callable 接口，聚合了 Runnable 对象
    return new RunnableAdapter<T>(task, result);
}



// --------------------------------- RunnableAdapter -----------------------------------
static final class RunnableAdapter<T> implements Callable<T> {
    final Runnable task;
    final T result;
    RunnableAdapter(Runnable task, T result) {
        this.task = task;
        this.result = result;
    }
    
    // 实际执行的是内部聚合的 Runnable 对象的 run()，并原样返回 result 值
    public T call() {
        task.run();
        return result;
    }
}

3. run()

我们知道 FutureTask 也是一个 Runnable 对象，线程执行 futureTask 的时候，入口是它的 run()；

FutureTask 的 run() 内部调用的是封装的 callable 的 call()；

public void run() {
    // 1. 如果当前 state != NEW || 当前任务被其他线程抢占执行，直接返回
    // 如果当前线程抢占当前 futureTask 成功，futureTask 的 runner 线程为当前线程
    if (state != NEW || !RUNNER.compareAndSet(this, null, Thread.currentThread()))
        return;

    // 此时 task 一定是 NEW 状态，并且当前线程抢占 task 成功，runner 为当前线程
    try {
        Callable<V> c = callable;
        if (c != null && state == NEW) {
            V result;
            boolean ran;

            try {
                // 2. 执行 callable.call()
                result = c.call();
                // callable.call() 执行成功，未抛出任何异常，ran 会设置为 true
                ran = true;
            } catch (Throwable ex) {
                // 2.1 callable.call() 抛出了异常，执行 setException(ex)
                result = null;
                ran = false;
                setException(ex);
            }

            if (ran)
                // 2.2 callable.call() 执行成功，执行 set(result)
                set(result);
        }
    } finally {
        runner = null;
        int s = state;
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}

3.1 set(result)

set(result) 会将任务执行的结果设置给 outcome，并调用 finishCompletion() 把 get() 中阻塞的线程都唤醒；

protected void set(V v) {
    // 将任务的状态，即 state 改为 COMPLETING
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        // 更新任务的结果 outcome 为 v
        outcome = v;
        
        // 将 result 赋值给 outcome 之后，马上会将当前任务状态修改为 NORMAL 正常结束状态
        UNSAFE.putOrderedInt(this, stateOffset, NORMAL);

        //把 get() 阻塞挂起的线程唤醒
        finishCompletion();
    }
}

3.2 setException(ex)

setException(ex) 会将任务执行的异常设置给 outcome，并调用 finishCompletion() 把 get() 中阻塞的线程都唤醒；

protected void setException(Throwable t) {
    // 将任务的状态，即 state 改为 COMPLETING
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        // 更新任务的结果 outcome 为异常 t
        outcome = t;
        
        // 将 t 赋值给 outcome 之后，马上会将当前任务状态修改为 EXCEPTIONAL 异常状态
        UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL);
        
        //把 get() 阻塞挂起的线程唤醒
        finishCompletion();
    }
}

4. get()

如果当前任务还未执行完，当前调用 get() 的线程会被阻塞挂起；

直到任务执行完，唤醒这些阻塞线程，并返回任务执行结果；

public V get() throws InterruptedException, ExecutionException {
    int s = state;
    
    // 如果当前任务是：未执行、正完成，调用 get() 的外部线程会被阻塞在 get() 上
    if (s <= COMPLETING)
        // awaitDone() 会将外部线程包装为 WaitNode，并阻塞挂起
        // 这些线程被唤醒时，awaitDone() 会返回 task 当前状态，这些线程在里面已经睡了一会了
        s = awaitDone(false, 0L);
	
    // 根据 state 状态，返回对应的结果 outcome
    return report(s);
}

4.1 report(s)

对 state 的状态：

  • normal 状态：正常执行状态，返回 Callable.call() 的结果；
  • cancelled 状态：被取消状态，抛出 CancellationException 异常；
  • exceptional 状态：异常状态，抛出 ExecutionException 异常；
private V report(int s) throws ExecutionException {
    
    // 正常情况下：outcome 保存的是 callable 运行结束的结果
    // 异常情况下：outcome 保存的是 callable 的 call() 产生的异常
    Object x = outcome;
    
    if (s == NORMAL)
        // 1. 正常执行状态，返回 Callable.call() 的结果
        return (V)x;

    if (s >= CANCELLED)
        // 2. 被取消状态，抛出 CancellationException 异常
        throw new CancellationException();

    // 3. 异常状态，抛出 ExecutionException 异常
    // ExecutionException 中的原始异常为 Callable.call() 中抛出的异常
    throw new ExecutionException((Throwable)x);
}

4.2 awaitDone(false, 0)

将当前线程包装为 WaitNode，作为新的链表头，并挂起阻塞当前线程；

  • 将当前线程包装为 WaitNode 入链表作为新链表头，并且将当前节点对应的线程挂起，LockSupport.park()；线程进入阻塞状态；
  • 线程什么时候会被唤醒呢？当任务被执行完成时，runner 线程会唤醒所有 WaitNode 中等待的线程；
private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
    final long deadline = timed ? System.nanoTime() + nanos : 0L;
    WaitNode q = null;
    boolean queued = false;

    // 进入自旋
    for (;;) {
        if (Thread.interrupted()) {
            removeWaiter(q);
            throw new InterruptedException();
        }

        // 1. 如果当前线程是被其它线程 unpark(thread) 唤醒的话
        // 获取当前任务最新状态，如果状态 state > COMPLETING，直接返回该 state
        int s = state;
        if (s > COMPLETING) {
            if (q != null)
                q.thread = null;
            return s;
        }
        
        // 2. 任务状态 state == COMPLETING，表示有其他线程即将执行完任务，当前线程等待一小段时间
        else if (s == COMPLETING)
            Thread.yield();
        
        // 3. 为当前线程创建 WaitNode
        else if (q == null)
            q = new WaitNode();
        else if (!queued){
            // 将当前线程的 WaitNode 入链表中，并且作为链表的头，queued 置为 true
            q.next = waiters;
            queued = UNSAFE.compareAndSwapObject(this, waitersOffset, waiters, q);
        }
        
        else if (timed) {
            // 4.1 含等待时间的挂起，执行 LockSupport.parkNanos(this, nanos) 阻塞一段时间
            nanos = deadline - System.nanoTime();
            if (nanos <= 0L) {
                removeWaiter(q);
                return state;
            }
            LockSupport.parkNanos(this, nanos);
        }
        else
            // 4.2 不含等待时间的挂起，执行 LockSupport.park(this)
            LockSupport.park(this);
    }
}

5. get(long timeout, TimeUnit unit)

含阻塞时间的 get()，当指定的超时时间到的时候任务还未执行完成，会抛出 TimeoutException；

public V get(long timeout, TimeUnit unit)
    throws InterruptedException, ExecutionException, TimeoutException {

    int s = state;
    
    // 如果当前任务是：未执行、正完成，调用 get() 的外部线程会被阻塞在 get() 上
    if (s <= COMPLETING &&
        // awaitDone() 会将外部线程包装为 WaitNode，并阻塞挂起
        // 这些线程被唤醒时，awaitDone() 会返回 task 当前状态，这些线程在里面已经睡了一会了
        // 指定的超时时间到的时候任务还未执行完成的话，抛出 TimeoutException
        (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
        throw new TimeoutException();
    return report(s);
}
买断
关注
  • 7
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java面试题-线程多线程.pdf
06-12
在Java编程中，线程多线程是核心概念之一，尤其在面试中经常被问到。下面我们将深入探讨这些知识点。 首先，我们来看Java中的线程创建方式： 1. **Thread 类的子类化**：通过继承 `Thread` 类并重写 `run()` 方法...
java多线程面试题59题集合
03-15
Java多线程是Java编程中的核心概念，它允许程序同时执行多个任务，从而提升系统效率。在面试中，对Java多线程的理解和熟练运用往往成为衡量开发者技能水平的重要标准。以下是对Java多线程面试题59题集合中可能涉及的...
Java多线程.pdf
09-28
Java多线程是Java编程中一个非常重要的概念，它允许程序在同一时间执行多个任务，从而提高了应用程序的效率和响应速度。在操作系统中，程序被加载到内存中形成进程，而进程中的执行单元就是线程。Java多线程的实现...
Java 多线程与并发(17-26)-JUC线程池- FutureTask详解.pdf
07-28
Java 多线程与并发(17_26)-JUC线程池_ FutureTask详解
多线程-day01.docx
12-12
在 Java 中，多线程是并发编程的重要概念，它允许程序同时执行多个任务，从而提高系统效率和资源利用率。在本教程中，我们将探讨多线程的基础知识，包括并发与并行的区别，进程与线程的概念，以及如何在 Java 中创建...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 577
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 909
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
Java面试题: 什么情况下索引会失效
qq_55630615的博客
07-02 407
通过执行计划EXPLAIN可以判断索引是否失效如果KEY和KEY_LEN为空代表索引失效。
ShardingSphere
Casual_Lei的博客
07-04 689
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
maven配置使用nexus仓库
ApexPredator的博客
07-03 251
maven配置使用nexus仓库
图片压缩代码和实际操作页面
英雄汉孑的博客
07-05 948
轻盈视界，高清依旧 —— 智能图片压缩，大容量，小体积，精彩不打折
基于SpringBoot的招聘信息管理系统的详细设计和实现(源码+lw+部署文档+讲解等，欢迎咨询我！！)
程序员阿龙的博客
07-06 897
本次分享的是一个基于java开发的招聘信息管理系统，也说明了自己的开发实力，欢迎各位小伙伴来咨询相关业务，也可以参考一下这个文章！！
JavaSE阶段面试题（一）
tq02的博客
07-03 640
本章节主要讲述SE阶段的常见面试题
返回值处理器器【Spring源码学习】
weixin_44794897的博客
07-05 275
定义返回值类型处理器的组合；测试使用的controller测试方法。
学习mybatis
最新发布
weixin_45621552的博客
07-08 436
【代码】学习mybatis。
基于springboot的工作绩效管理系统的设计与实现+文档
欧阳小白闯天涯
07-05 686
本毕业设计旨在设计与实现基于Spring Boot的工作绩效管理系统，以满足现代企业对绩效管理的需求。随着企业规模的不断扩大和竞争日益激烈，高效的绩效管理成为提升企业竞争力的重要手段。本系统将利用Spring Boot框架搭建，结合MySQL数据库和MyBatis持久层框架，以及Thymeleaf模板引擎，为企业提供全面的绩效管理解决方案。系统功能包括员工和管理员两个角色。员工可通过系统进行绩效管理、工资管理、统计分析、请假管理以及公告管理等操作，从而提升工作效率和满足个人需求。
Java 汉诺塔问题 详细分析
2301_80641575的博客
07-02 289
汉诺塔问题
学java的第3天 后端商城小程序工作
weixin_67865831的博客
07-05 328
我的图片表中有一个字段是描述我写成desc了，正好是mysql中的关键字 就不能使用了。
Android | RxJava 中的调度器（Schedulers）的主要作用是什么？
liuruiaaa的博客
07-03 301
Android | RxJava 中的调度器（Schedulers）的主要作用是什么？
Java多线程-多线程知识点总结和企业真题
02-04
Java多线程--多线程知识点总结和企业真题

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值