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获取)
![img](https://i-blog.csdnimg.cn/blog_migrate/cde3adb4d80b256143bab177b12371fc.jpeg)
文末
我将这三次阿里面试的题目全部分专题整理出来,并附带上详细的答案解析,生成了一份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面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》,点击传送门即可获取!