【线程】拎清FutureTask源码

_多喝水_2024-03-26 17:31

1. 结论先行

1.1 FutreTask作用

引用官方文档的注释：A {@code Future} represents the result of an asynchronous computation（ Future对象，表示一个异步计算的结果）。即可以获取异步线程的返回值

1.2 用法

  • 配合Thread使用
java 复制代码 
public static void main(String[] args) throws ExecutionException, InterruptedException { 
	// 定义一个FutureTask任务  
	Future<String> strFuture = new FutureTask<>(() -> {  
		log.info("##开始执行异步任务##");  
		Thread.sleep(2000); // 休眠2s  
		return Thread.currentThread().getName(); // 返回异步线程的名称  
	});  

	Thread t = new Thread((Runnable) strFuture);  
	t.start();  
	log.info("111::" + Thread.currentThread().getName() + "线程正在运行！");  
	// 此处就可以处理其他逻辑  
	log.info("获取异步线程名称：：" + strFuture.get());  
	log.info("222::" + Thread.currentThread().getName() + "线程正在运行！");  
}

输出结果：

java 复制代码 
[2024-03-26 10:26:52] [INFO]: 111::main线程正在运行！
[2024-03-26 10:26:52] [INFO]: ##开始执行异步任务##
// 停顿了2秒，等待异步线程返回结果
[2024-03-26 10:26:54] [INFO]: 获取异步线程名称：：Thread-0
[2024-03-26 10:26:54] [INFO]: 222::main线程正在运行！
  • 配合线程池使用：
java 复制代码 
public static void main(String[] args) throws ExecutionException, InterruptedException {  
	// 定义一个FutureTask任务  
	Future<String> strFuture = new FutureTask<>(() -> {  
		log.info("##开始执行异步任务##");  
		Thread.sleep(3000);  
		return Thread.currentThread().getName();  // 返回异步线程的名称
	});  
	ThreadPoolExecutor executor = new ThreadPoolExecutor(2,4,5,  
			TimeUnit.MILLISECONDS,new ArrayBlockingQueue<>(40));  
	executor.submit((Runnable) strFuture);  
	log.info("111::" + Thread.currentThread().getName() + "线程正在运行！");  
	log.info("获取异步线程名称：：" + strFuture.get());  
	log.info("222::" + Thread.currentThread().getName() + "线程正在运行！");  
}

运行结果：

java 复制代码 
[2024-03-26 10:31:23] [INFO] : 111::main线程正在运行！
[2024-03-26 10:31:23] [INFO] : ##开始执行异步任务##
// 停顿了3秒，等待异步线程返回结果
[2024-03-26 10:31:26] [INFO] : 获取异步线程名称：：pool-1-thread-1
[2024-03-26 10:31:26] [INFO] : 222::main线程正在运行！

2. 探索（源码）之旅

2.1 类结构

  • 首先看一下FutureTask的继承，有个整体概念

FutureTask本质上也是实现了Runnable。同时实现了Future接口获取异步计算的功能。

  • 接着看一下FutureTask的构造函数：有两个构造函数
java 复制代码 
// 接收一个callable对象
public FutureTask(Callable<V> callable) {
   if (callable == null)
       throw new NullPointerException();
   this.callable = callable;
   this.state = NEW;       // ensure visibility of callable
}

// 也可以接收一个runnable，但也会被装饰成一个callable
// result参数，其实就是返回值，从某种程度上说，返回值是写死的
public FutureTask(Runnable runnable, V result) {
   // 将runnable封装成了一个callable对象
   this.callable = Executors.callable(runnable, result);
   this.state = NEW;       // ensure visibility of callable
}

可以看出构造函数就是接收了一个callable对象，即使接收runnable，也把它装饰成了callable对象。我们分别看一下Callable接口和封装过程：

java 复制代码 
@FunctionalInterface  
public interface Callable<V> {  
     V call() throws Exception;  
}

将Runnable封装为Callable:

java 复制代码 
// Executors.callable方法：
public static <T> Callable<T> callable(Runnable task, T result) {  
    if (task == null)  
        throw new NullPointerException();  
    // 就简单的封装成了一个RunnableAdapter对象
    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;
   }
   public T call() {
       task.run();
       return result; // 返回值是写死的
   }
}
  • 了解完FutrueTask类继承结构和构造函数，再看一下它的几个重要成员变量：
java 复制代码 
/**
* 任务的运行状态，初始化是NEW状态。
* 只有在setException和cancel方法中，会把状态转化为 terminal（EXCEPTIONAL，CANCELLED） 状态。
* 在运行期间，state的值可能会短暂的变成COMPLETING（outcome值被赋值时）或者INTERRUPTING（只有
* 试图中断线程，且调用了cancel(true)方法）。
* 
* 任务运行状态的几种转化形态:
* 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; // 任务正常执行完成
private static final int EXCEPTIONAL  = 3; // 任务执行过程抛出异常
private static final int CANCELLED    = 4; // 手动中止任务，但不中断正在执行中的任务线程
private static final int INTERRUPTING = 5; // 手动中止任务，中断正在执行中的任务线程
private static final int INTERRUPTED  = 6; // 已手动中止任务

/** 任务对象; 执行任务结束后，置为null */
private Callable<V> callable;
/** 任务执行的结果或者抛出的异常对象 */
private Object outcome; // non-volatile, protected by state reads/writes
/** 执行callable的任务线程; CASed during run() */
private volatile Thread runner;
/** 不知道咋翻译，看后续源码理解 */
private volatile WaitNode waiters;
  • 另外再补充一个FutureTask中使用UNSAFE类cas操作的知识，源码中有用到：
java 复制代码 
// FutureTask类中使用了UNSAFE类，进行CAS操作 
private static final sun.misc.Unsafe UNSAFE;  
private static final long stateOffset;  // state变量在JVM中游标位置
private static final long runnerOffset; // runner变量在JVM中游标位置
private static final long waitersOffset; // waiters变量在JVM中游标位置
static {  
    try {  
        UNSAFE = sun.misc.Unsafe.getUnsafe();  
        Class<?> k = FutureTask.class;  
        // 获取游标位置
        stateOffset = UNSAFE.objectFieldOffset  
            (k.getDeclaredField("state"));  
        runnerOffset = UNSAFE.objectFieldOffset  
            (k.getDeclaredField("runner"));  
        waitersOffset = UNSAFE.objectFieldOffset  
            (k.getDeclaredField("waiters"));  
    } catch (Exception e) {  
        throw new Error(e);  
    }  
}

// 在本次阅读源码中用到UNSAFE的两个方法：
/**
* 当指定实例{var1}的成员变量{var2}的值和我们期望的值{var4}相等时，则将新值{var5}赋予该变量{var2}
* 
* @param var1 包含要修改的 int 值的对象的引用
* @param var2 要修改的 int 值在对象中的偏移量（从对象的内存地址开始计算的字节数）。
* @param var4 期望值（即我们期望在对象当前位置的值）。
* @param var5 新值（如果期望的值与当前值匹配，则设置此新值）
*/
 public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

/**
* 当指定实例{var1}的成员变量{var2}的值和我们期望的值{var4}相等时，则将新值{var5}赋予该变量{var2}
* 
* @param var1 包含要修改的 对象 值的对象的引用。
* @param var2 要修改的 对象 值在对象中的偏移量（从对象的内存地址开始计算的字节数）。
* @param var4 期望值（即我们期望在对象当前位置的值）。
* @param var5 新值（如果期望的值与当前值匹配，则设置此新值）
*/
 public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);

只要知道compareAndSwapInt和compareAndSwapObject两个方法的作用即可。

2.2 流程逻辑

FutureTask代表异步计算的结果，实现了runnable接口，那么它的入口必定是run()方法：

java 复制代码 
public void run() {
    // 检查任务运行状态
    if (state != NEW ||
        // 赋值 runner 对象，赋值失败，直接return(就是把当前正在运行的thread对象赋值给runner)
        !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                     null, Thread.currentThread()))
        return;
    try {
        Callable<V> c = callable;
        // 再次判断任务的运行状态；任务对象非null
        if (c != null && state == NEW) {
            V result;
            boolean ran; // 任务是否执行成功
            try {
                result = c.call(); // 执行真正的任务逻辑
                ran = true;
            } catch (Throwable ex) {
                result = null;
                ran = false;
                setException(ex); // 执行任务异常，设置运行状态为EXCEPTIONAL，并赋值到outcome
            }
            if (ran)
                // 如果任务正常运行结束，设置运行状态为NORMAL，并赋值到outcome
                set(result);
        }
    } finally {
        // 直到state状态尘埃落定后，runner 变量才可以被置null
        // 防止run()方法被重复调用，导致线程安全问题
        runner = null;
        // state must be re-read after nulling runner to prevent
        // leaked interrupts
        int s = state;
        // 若任务线程被中断，死循环到任务状态为INTERRUPTED
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}

这里的整体逻辑其实比较简单，就是调用的callable对象的call()方法，将返回值赋值给outcome：

java 复制代码 
/**
 * 任务正常执行结束，将结果赋值给outcome，将运行状态设置为：NORMAL
 */
protected void set(V v) {
	// 判断state状态正确，并赋值为COMPLETING
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        outcome = v;
        // 将state赋值为NORMAL
        UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
        finishCompletion(); // 做任务结束处理
    }
}

执行任务逻辑抛异常处理：

java 复制代码 
/**
 * 运行任务异常，将运行状态设置为：EXCEPTIONAL
 */
protected void setException(Throwable t) {
	// 判断state状态正确，并赋值为COMPLETING
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        outcome = t;
        // 将state赋值为EXCEPTIONAL
        UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
        finishCompletion(); // 做任务结束处理
    }
}

执行任务的逻辑比较简单，稍微复杂点的是获取结果的逻辑。Future提供了两个get()方法来获取返回值：

java 复制代码 
/**
 * 获取处理结果
 */
public V get() throws InterruptedException, ExecutionException {
    int s = state;
    if (s <= COMPLETING) // 判断任务状态，若未执行结束，则阻塞等待
        s = awaitDone(false, 0L);
    return report(s); // 返回结果，注意该对象若是Exception，会抛出异常
}

/**
 * 获取处理结果,设置等待时间，超时抛异常
 */
public V get(long timeout, TimeUnit unit)
    throws InterruptedException, ExecutionException, TimeoutException {
    if (unit == null)
        throw new NullPointerException();
    int s = state;
    if (s <= COMPLETING && // 判断任务状态
	     // 超时后，状态仍为未完成状态（NEW,COMPLETING），则抛异常
        (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
        throw new TimeoutException();
    return report(s); // 返回结果，注意该对象若是Exception，会抛出异常
}

看下awaitDone()方法：

java 复制代码 
/**
 * 等待计算结果 或者 在线程被中断或者超时时放弃等待
 *
 * @param timed true时，会判断超时
 * @param nanos 设置等待超时的时间
 * @return 计算结束后的state
 */
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();
        }

        int s = state;
        if (s > COMPLETING) { // 任务处理已经结束
            if (q != null)
                q.thread = null;
            return s;
        }
        else if (s == COMPLETING) // 任务已经处理完毕，但还未到最终状态
            Thread.yield(); // 主动释放cpu，等待被唤醒
        else if (q == null) // 如果WaitNode对象为空，创建一个新的
            q = new WaitNode();
        else if (!queued) 
            // 将上一行创建的WaitNode赋值给成员变量waiters
            // 这里是为了任务执行完毕后，能够唤醒"查询结果"的线程
            queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                 q.next = waiters, q);
        else if (timed) { // 设置了超时时间
            nanos = deadline - System.nanoTime();
            if (nanos <= 0L) { // 已经超时
                removeWaiter(q);
                return state;
            }
            LockSupport.parkNanos(this, nanos); // 将当前对象上锁
        }
        else // 等待结果没有时间限制
            LockSupport.park(this);
    }
}

等待结果的逻辑，我们主要关注WaitNode()对象，我们先看下它的结构：

java 复制代码 
static final class WaitNode {  
    volatile Thread thread;  
    volatile WaitNode next;  
    WaitNode() { thread = Thread.currentThread(); }  
}

结构很简单，保存了一个当前thread对象和一个next节点。然后我们一步一步分析awaitDone()方法中关于WaitNode对象的逻辑：

  1. 当我们调用get()方法时，假设任务逻辑还在执行，逻辑肯定进入到q == null判断分支中，它实例化了一个WaitNode对象，将当前调用get()方法的Thread对象放到了WaitNode对象中，且将WaitNode值赋给变量q。
  2. awaitDone()方法中的for循环进行第二次循环，此时我们再假设任务还在运行中。此时，逻辑进入到!queued的判断分支中，此时 q.next = waiters 返回的是null,和waitersOffset游标指向的变量（waiters）是相等的，cas操作判断正常。将q对象赋值给了成员变量waiters。
  3. 若任务还在运行中，没有结束，在后面的循环中，要么进入timed判断分支，要么就是最后的else判断分支，都是挂起当前线程，阻塞等待了。
  4. 此时我们再回过来看run()方法，任务执行结束后，设置state为最终状态时（setException()和set()方法）是不是都调用了finishCompletion()，我们来细究一下：
java 复制代码 
private void finishCompletion() {
   // 成员属性waiters 不为空，说明主线程在等待"任务"结果,就是步骤2干的事
   for (WaitNode q; (q = waiters) != null;) {
        // 将成员属性waiters置为null（cas判断操作）
       if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) { 
           for (;;) {
               Thread t = q.thread; // 获取主线程的thread对象（在步骤1中赋值的）
               if (t != null) {
                   q.thread = null;
                   LockSupport.unpark(t); // 释放锁，唤起主线程
               }
               WaitNode next = q.next;
               if (next == null)
                   break;
               q.next = null; // unlink to help gc
               q = next;
           }
           break;
       }
   }

   done(); // 扩展接口

   callable = null;        // to reduce footprint
}

这样awaitDone()方法就会在等待任务执行结束后，返回任务状态。我们再返回来看get()方法中的report()方法逻辑：

java 复制代码 
private V report(int s) throws ExecutionException {  
    Object x = outcome;  
    if (s == NORMAL)  // 要是任务正常结束，则正常返回结果值
        return (V)x;  
    // 根据任务没有正常结束，根据任务的状态抛出不同的异常
    if (s >= CANCELLED) 
        throw new CancellationException();  
    throw new ExecutionException((Throwable)x);  
}

至此FutureTask的主线逻辑都已清晰。支线逻辑（中断任务线程等），自个再看看，加深源码阅读的理解和兴趣。

3. 总结

整体流程：

相关推荐
Q_19284999069 分钟前
基于Spring Boot的摄影器材租赁回收系统
java·spring boot·后端
Code_流苏12 分钟前
VSCode搭建Java开发环境 2024保姆级安装教程（Java环境搭建+VSCode安装+运行测试+背景图设置）
java·ide·vscode·搭建·java开发环境
良许Linux14 分钟前
0.96寸OLED显示屏详解
linux·服务器·后端·互联网
求知若饥26 分钟前
NestJS 项目实战-权限管理系统开发（六）
后端·node.js·nestjs
禁默1 小时前
深入浅出：AWT的基本组件及其应用
java·开发语言·界面编程
Cachel wood1 小时前
python round四舍五入和decimal库精确四舍五入
java·linux·前端·数据库·vue.js·python·前端框架
Code哈哈笑1 小时前
【Java 学习】深度剖析Java多态：从向上转型到向下转型，解锁动态绑定的奥秘，让代码更优雅灵活
java·开发语言·学习
gb42152871 小时前
springboot中Jackson库和jsonpath库的区别和联系。
java·spring boot·后端
程序猿进阶1 小时前
深入解析 Spring WebFlux：原理与应用
java·开发语言·后端·spring·面试·架构·springboot
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10红米手机使用google play