【线程】拎清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. 总结

整体流程：

相关推荐
XiaoLeisj2 小时前
【JavaEE初阶 — 多线程】单例模式 ＆ 指令重排序问题
java·开发语言·java-ee
paopaokaka_luck2 小时前
【360】基于springboot的志愿服务管理系统
java·spring boot·后端·spring·毕业设计
dayouziei2 小时前
java的类加载机制的学习
java·学习
码农小旋风3 小时前
详解K8S--声明式API
后端
Peter_chq3 小时前
【操作系统】基于环形队列的生产消费模型
linux·c语言·开发语言·c++·后端
Yaml44 小时前
Spring Boot 与 Vue 共筑二手书籍交易卓越平台
java·spring boot·后端·mysql·spring·vue·二手书籍
小小小妮子~4 小时前
Spring Boot详解：从入门到精通
java·spring boot·后端
hong1616884 小时前
Spring Boot中实现多数据源连接和切换的方案
java·spring boot·后端
aloha_7894 小时前
从零记录搭建一个干净的mybatis环境
java·笔记·spring·spring cloud·maven·mybatis·springboot
记录成长java5 小时前
ServletContext,Cookie,HttpSession的使用
java·开发语言·servlet
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play