浅谈Java多线程之FutureTask

private static final int EXCEPTIONAL = 3;

private static final int CANCELLED = 4;

private static final int INTERRUPTING = 5;

private static final int INTERRUPTED = 6;

状态含义分别是：

●     0-刚创建

●     1-即将完成

●     2-完成

●     3-抛异常

●     4-任务取消

●     5-任务即将被打断

●     6-任务被打断

为什么要设置这些状态呢，那是因为FutureTask=任务+结果，调用者何时可以去获取这个结果result呢？FutureTask在调用get方法时，会去判断当前任务的状态，只有当任务完成才会给你实际的result，因此get方法是阻塞的。

FutureTask的get() 方法

====================

先看下FutureTask的get() 方法是如何使用的：

FutureTask task = new FutureTask(new Callable() {

@Override

public Object call() throws Exception {

System.out.println(Thread.currentThread().getName() + “========>正在执行！”);

Thread.sleep(2000); //执行耗时操作

return “SUCCESS”;

}

});

new Thread(task).start();

System.out.println(task.get());

效果：

Thread-0========>正在执行！

SUCCESS

过了两秒后才打印出SUCCESS，说明get确实是阻塞的。再来一个线程池的例子：

ExecutorService executorService = Executors.newSingleThreadExecutor();

/**

• 往线程池中提交一个Callable，立刻返回Future对象，但是该Future对象里面的返回值目前还是null

• 只有当你调用get方法时，才会阻塞地获取该任务真实的返回值

*/

Future objectFuture = executorService.submit(new Callable() {

@Override

public Object call() throws Exception {

System.out.println(Thread.currentThread().getName() + “========>正在执行！”);

Thread.sleep(2000); //执行耗时操作

return “SUCCESS”;

}

});

Object result = objectFuture.get();

System.out.println(result);

executorService.shutdownNow();

FutureTask的run方法

================

先来看看源代码吧：

public void run() {

if (state != NEW ||

!UNSAFE.compareAndSwapObject(this, runnerOffset,

null, Thread.currentThread()))

return;

try {

Callable c = callable;

if (c != null && state == NEW) {

V result;

boolean ran;

try {

result = c.call();

ran = true;

} catch (Throwable ex) {

result = null;

ran = false;

setException(ex);

}

if (ran)

set(result);

}

} finally {

// runner must be non-null until state is settled to

// prevent concurrent calls to run()

runner = null;

// state must be re-read after nulling runner to prevent

// leaked interrupts

int s = state;

if (s >= INTERRUPTING)

handlePossibleCancellationInterrupt(s);

}

}

FutureTask的run方法第一步果然是获取callable对象，这个callable对象也可能是runnable伪装的，上面介绍了适配器模式，这边就不再赘述了。

最终是存储到outcome对象了，简而言之，FutureTask的run方法的作用就是运行callable的call方法，拿到返回值保存到outcome对象，等待有人来取。

薛定谔的FutureTask

==============

为什么说是薛定谔的FutureTask呢？那是因为，当你把FutureTask跑起来的时候，里面的outcome可能没有值，也可能有值。

但是又因为outcome在FutureTask源码中被设置成private，所以如果你要获取这个数据，只能通过get方法。而get方法是阻塞的，当你调用get方法时，一定是等到任务执行成功后，才会返回真实的值。

这就有点像薛定谔的猫，你不去观察它，两种状态皆有可能，一旦你去观察了（调用get方法），就只有一种明确的状态。

其实这真的只是一个小技巧，相信你也能办到，我们用代码来模拟一下这个过程。

首先，新建一个MyFutureTask类：

/**

• 自定义任务类

*/

public class MyFutureTask implements Runnable{

/**

• 为了看到效果，outcome设置为Object

*/

public Object outcome;

public void run(){

try {

/**

• 执行耗时操作

*/

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

/**

• 给outcome赋值

*/

this.outcome = “SUCCESS”;

}

public Object get(){

return outcome;

}

}

为了模拟线程池，新建一个MyExecutorService类：

class MyExecutorService {

/**

• 提交任务

• @param myFutureTask

• @return

*/

public MyFutureTask submit(MyFutureTask myFutureTask){

/**

• 开启一个线程把myFutureTask跑掉

*/

new Thread(myFutureTask).start();

/**

• 线程有没有跑完不关心，直接把myFutureTask返回

• 此时myFutureTask很可能不是最终结果，但其中的outcome一定指向最终结果

*/

return myFutureTask;

}

}

测试：

public static void main(String[] args) throws InterruptedException {

MyExecutorService myExecutorService = new MyExecutorService();

MyFutureTask myFutureTask = myExecutorService.submit(new MyFutureTask());

/**

• 线程开启立刻查看outcome

*/

System.out.println(myFutureTask.outcome);

/**

• 主线程继续运作

*/

Thread.sleep(1100);

/**

• 再次查看outcome是否有值

*/

System.out.println(myFutureTask.get());

}

结果：

null

SUCCESS

总结一下，ExecutorService的submit方法只是提交Runnable或Callable任务到线程池，直接返回FutureTask给你，这个FutureTask是薛定谔的FutureTask，里面的outcome现在可能有值，也可能没有。只有当你主动调用get方法，才可以得到确切的值。

FutureTask的get方法阻塞原理

=====================

FutureTask的get方法是阻塞的，当你调用这个方法就一定要等该线程跑完，那么为什么能做到这样呢？

接下来我们看看get方法的阻塞原理是什么，我重新写了一个例子，注释能写的都写了，代码如下：

package com.javaxbfs.thread;

import java.util.concurrent.locks.LockSupport;

class MyExecutorService {

/**

• 提交任务

• @param myFutureTask

• @return

*/

public MyFutureTask submit(MyFutureTask myFutureTask){

/**

• 开启一个线程把myFutureTask跑掉

*/

Thread thread = new Thread(myFutureTask);

thread.start();

/**

• 把线程赋给myFutureTask的runner属性，以方便查看线程状态

*/

myFutureTask.runner = thread;

/**

• 线程有没有跑完不关心，直接把myFutureTask返回

• 此时myFutureTask很可能不是最终结果，但其中的outcome一定指向最终结果

*/

return myFutureTask;

}

}

/**

• 自定义任务类

*/

public class MyFutureTask implements Runnable{

/**

• 为了看到效果，outcome设置为Object

*/

public Object outcome;

/**

• 当前任务所在的线程

*/

public volatile Thread runner;

public void run(){

try {

/**
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

文末

我将这三次阿里面试的题目全部分专题整理出来，并附带上详细的答案解析，生成了一份PDF文档

• 第一个要分享给大家的就是算法和数据结构

• 第二个就是数据库的高频知识点与性能优化

• 第三个则是并发编程（72个知识点学习）

• 最后一个是各大JAVA架构专题的面试点+解析+我的一些学习的书籍资料

还有更多的Redis、MySQL、JVM、Kafka、微服务、Spring全家桶等学习笔记这里就不一一列举出来

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！
95254671a72faed303032d36.jpg" alt=“img” style=“zoom: 33%;” />

文末

我将这三次阿里面试的题目全部分专题整理出来，并附带上详细的答案解析，生成了一份PDF文档

• 第一个要分享给大家的就是算法和数据结构

[外链图片转存中…(img-7yQANKqy-1712483640166)]

• 第二个就是数据库的高频知识点与性能优化

[外链图片转存中…(img-3KKnGRJR-1712483640166)]

• 第三个则是并发编程（72个知识点学习）

[外链图片转存中…(img-MsBnyL5p-1712483640166)]

• 最后一个是各大JAVA架构专题的面试点+解析+我的一些学习的书籍资料

[外链图片转存中…(img-KubppRpm-1712483640167)]

还有更多的Redis、MySQL、JVM、Kafka、微服务、Spring全家桶等学习笔记这里就不一一列举出来

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！