FutureTask类提供了可取消的异步计算,并且可以利用开始和取消计算的方法、查询计算是否完成的方法和获取计算结果的方法。

首先看一下继承关系

  1. public class FutureTask<V> implements RunnableFuture<V>
  1. public interface RunnableFuture<V> extends Runnable, Future<V> {
  2. void run();
  3. }

FutureTask -> RunnableFuture -> Runnable,Future  Runnable我们都知道就不说了,主要看一下Future接口。

  1. public interface Future<V> {
  2.  
  3. //试图取消对此任务的执行。
  4. boolean cancel(boolean mayInterruptIfRunning);
  5.  
  6. //如果在任务正常完成前将其取消,则返回 true。
  7. boolean isCancelled();
  8.  
  9. //如果任务已完成,则返回 true。
  10. boolean isDone();
  11.  
  12. //如有必要,等待计算完成,然后获取其结果。
  13. V get() throws InterruptedException, ExecutionException;
  14.  
  15. //如有必要,最多等待为使计算完成所给定的时间之后,获取其结果(如果结果可用)。
  16. V get(long timeout, TimeUnit unit)
  17. throws InterruptedException, ExecutionException, TimeoutException;
  18. }

也就是说当FutureTask的实例被一个线程执行以后,我们可以对它进行控制,比如终止任务,查询任务是否完成,获取结果等。

  1. public class FutureTask<V> implements RunnableFuture<V> {
  2.  
  3. /**
  4. * 这个类可能的几种过度状态
  5. * NEW -> COMPLETING -> NORMAL 新建-正在完成-正常完成
  6. * NEW -> COMPLETING -> EXCEPTIONAL 新建-正在完成-异常
  7. * NEW -> CANCELLED 新建-取消
  8. * NEW -> INTERRUPTING -> INTERRUPTED 新建-正在中断线程-已经中断
  9. */
  10. private volatile int state; //当前状态 注意volatile,因为这个类是为多线程使用而设计的
  11. private static final int NEW = 0;
  12. private static final int COMPLETING = 1;
  13. private static final int NORMAL = 2;
  14. private static final int EXCEPTIONAL = 3;
  15. private static final int CANCELLED = 4;
  16. private static final int INTERRUPTING = 5;
  17. private static final int INTERRUPTED = 6;
  18.  
  19. /** 用于执行任务并且返回结果 */
  20. private Callable<V> callable;
  21. /** 用于存放返回结果 另外如果出现异常那么就存放异常的引用 */
  22. private Object outcome; // non-volatile, protected by state reads/writes
  23. /** 当前执行该类的线程 */
  24. private volatile Thread runner;
  25. /** 等待锁队节点 */
  26. private volatile WaitNode waiters;
  27.  
  28. /**
  29. * 根据state的值,判断任务是否正常完成。
  30. *
  31. * @param s 当前的状态值
  32. */
  33. @SuppressWarnings("unchecked")
  34. private V report(int s) throws ExecutionException {
  35. Object x = outcome;
  36. //如果状态为NORMAL 则正常返回结果。
  37. if (s == NORMAL)
  38. return (V)x;
  39. //如果状态>=CANCELLED 则抛出一个异常CancellationException 告诉用户任务已经终止。
  40. if (s >= CANCELLED)
  41. throw new CancellationException();
  42. //否则就是任务执行过程中出现异常,包装一下直接抛出。
  43. throw new ExecutionException((Throwable)x);
  44. }
  45.  
  46. /**
  47. * 构造参数 传入callable对象,并且将当前状态state设置为null。
  48. */
  49. public FutureTask(Callable<V> callable) {
  50. if (callable == null)
  51. throw new NullPointerException();
  52. this.callable = callable;
  53. this.state = NEW; // ensure visibility of callable
  54. }
  55.  
  56. /**
  57. * 传入runnable对象和result
  58. * 通过Executors包装一下,还是返回一个callable的实例
  59. * 在执行完runnable的任务后直接返回result
  60. */
  61. public FutureTask(Runnable runnable, V result) {
  62. this.callable = Executors.callable(runnable, result);
  63. this.state = NEW; // ensure visibility of callable
  64. }
  65.  
  66. /*
  67. * 判断任务是否取消
  68. */
  69. public boolean isCancelled() {
  70. return state >= CANCELLED;
  71. }
  72.  
  73. /*
  74. * 如果任务已完成,则返回 true。
  75. * 可能由于正常终止、异常或取消而完成,在所有这些情况中,此方法都将返回 true。
  76. */
  77. public boolean isDone() {
  78. return state != NEW;
  79. }
  80.  
  81. /**
  82. * 取消任务
  83. * mayInterruptIfRunning 如果应该中断执行此任务的线程,则为 true;否则允许正在运行的任务运行完成
  84. */
  85. public boolean cancel(boolean mayInterruptIfRunning) {
  86. //如果当前状态不是新创建时的状态 那么返回false
  87. //这种情况说明任务已经执行,那么当前状态的值就有俩种情况。
  88. //一种是任务正常完成 那么当前状态将的值会按照这个方向执行 NEW -> COMPLETING -> NORMAL
  89. //一种任务是执行中出现异常 那么当前状态的值会按照这个方向执行 NEW -> COMPLETING -> EXCEPTIONAL
  90. if (state != NEW)
  91. return false;
  92.  
  93. if (mayInterruptIfRunning) {
  94. //设置当前状态为INTERRUPTING(正在设置线程的中断状态)
  95. if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, INTERRUPTING))
  96. return false;
  97. Thread t = runner;
  98. if (t != null)
  99. //设置线程的中断状态
  100. t.interrupt();
  101. //设置当前状态为INTERRUPTED
  102. UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED); // final state
  103. }
  104. //如果当前状态为NEW 那么会把当前状态设置为 CANCELLED 然后调用finishCompletion,然后返回成功
  105. else if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, CANCELLED))
  106. return false;
  107. //这个方法下面解释
  108. finishCompletion();
  109. return true;
  110. }
  111.  
  112. /**
  113. * 获取任务的结果,如果任务未完成则线程进入等待状态。
  114. */
  115. public V get() throws InterruptedException, ExecutionException {
  116. int s = state;
  117. //如果任务未完成
  118. if (s <= COMPLETING)
  119. //等待完成 里面的是实现是等待队列
  120. s = awaitDone(false, 0L);
  121. //调用report方法来根据情况返回结果
  122. return report(s);
  123. }
  124.  
  125. /**
  126. * 最多等待为使计算完成所给定的时间之后,获取其结果。
  127. */
  128. public V get(long timeout, TimeUnit unit)
  129. throws InterruptedException, ExecutionException, TimeoutException {
  130. if (unit == null)
  131. throw new NullPointerException();
  132. int s = state;
  133. //如果超时任务未能完成就抛出TimeoutException
  134. if (s <= COMPLETING &&
  135. (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
  136. throw new TimeoutException();
  137. //调用report方法来根据情况返回结果
  138. return report(s);
  139. }
  140.  
  141. /**
  142. * 给子类扩展的方法,state状态发生改变时被调用。
  143. */
  144. protected void done() { }
  145.  
  146. protected void set(V v) {
  147. //将状态先设置为COMPLETING正在完成,然后再设置为正常NORMAL
  148. if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
  149. outcome = v;
  150. UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
  151. //然后调用完成方法
  152. finishCompletion();
  153. }
  154. }
  155.  
  156. protected void setException(Throwable t) {
  157. //将状态先设置为COMPLETING正在完成,然后再设置为异常EXCEPTIONAL
  158. if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
  159. outcome = t;
  160. UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
  161. //然后调用完成方法
  162. finishCompletion();
  163. }
  164. }
  165.  
  166. //任务开始方法
  167. public void run() {
  168. //任务不能多个线程同时运行。
  169. //如果第一次运行将runner设置为当前执行的线程。
  170. if (state != NEW ||
  171. !UNSAFE.compareAndSwapObject(this, runnerOffset,
  172. null, Thread.currentThread()))
  173. return;
  174. try {
  175. Callable<V> c = callable;
  176. if (c != null && state == NEW) {
  177. V result;
  178. boolean ran;
  179. try {
  180. result = c.call();
  181. //任务正常完成 也就是没有出现异常,那么ran=true
  182. ran = true;
  183. } catch (Throwable ex) {
  184. //出现异常就调用setException方法,将状态state设置为EXCEPTIONAL
  185. result = null;
  186. ran = false;
  187. setException(ex);
  188. }
  189. //如果上面任务正常完成则调用set方法,那么将状态state设置为NORMAL
  190. if (ran)
  191. set(result);
  192. }
  193. } finally {
  194. runner = null;
  195. int s = state;
  196. //这里要判断一下,任务是否被取消过。
  197. if (s >= INTERRUPTING)
  198. handlePossibleCancellationInterrupt(s);
  199. }
  200. }
  201.  
  202. /**
  203. * Executes the computation without setting its result, and then
  204. * resets this future to initial state, failing to do so if the
  205. * computation encounters an exception or is cancelled. This is
  206. * designed for use with tasks that intrinsically execute more
  207. * than once.
  208. *
  209. * @return true if successfully run and reset
  210. */
  211. protected boolean runAndReset() {
  212. if (state != NEW ||
  213. !UNSAFE.compareAndSwapObject(this, runnerOffset,
  214. null, Thread.currentThread()))
  215. return false;
  216. boolean ran = false;
  217. int s = state;
  218. try {
  219. Callable<V> c = callable;
  220. if (c != null && s == NEW) {
  221. try {
  222. c.call(); // don't set result
  223. ran = true;
  224. } catch (Throwable ex) {
  225. setException(ex);
  226. }
  227. }
  228. } finally {
  229. // runner must be non-null until state is settled to
  230. // prevent concurrent calls to run()
  231. runner = null;
  232. // state must be re-read after nulling runner to prevent
  233. // leaked interrupts
  234. s = state;
  235. if (s >= INTERRUPTING)
  236. handlePossibleCancellationInterrupt(s);
  237. }
  238. return ran && s == NEW;
  239. }
  240.  
  241. /**
  242. * 如果其他线程正在中午该任务,那么运行该任务的线程就暂时让出CPU时间
  243. * 一直到state=INTERRUPTED为止。
  244. */
  245. private void handlePossibleCancellationInterrupt(int s) {
  246.  
  247. if (s == INTERRUPTING)
  248. while (state == INTERRUPTING)
  249. Thread.yield(); // wait out pending interrupt
  250. }
  251.  
  252. /**
  253. * Simple linked list nodes to record waiting threads in a Treiber
  254. * stack. See other classes such as Phaser and SynchronousQueue
  255. * for more detailed explanation.
  256. */
  257. static final class WaitNode {
  258. volatile Thread thread;
  259. volatile WaitNode next;
  260. WaitNode() { thread = Thread.currentThread(); }
  261. }
  262.  
  263. /**
  264. * 解锁所有等待队列当中的线程,让他们调用done方法。
  265. */
  266. private void finishCompletion() {
  267. // assert state > COMPLETING;
  268. for (WaitNode q; (q = waiters) != null;) {
  269. if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
  270. for (;;) {
  271. Thread t = q.thread;
  272. if (t != null) {
  273. q.thread = null;
  274. LockSupport.unpark(t);
  275. }
  276. WaitNode next = q.next;
  277. if (next == null)
  278. break;
  279. q.next = null; // unlink to help gc
  280. q = next;
  281. }
  282. break;
  283. }
  284. }
  285.  
  286. done();
  287.  
  288. callable = null; // to reduce footprint
  289. }
  290.  
  291. /**
  292. * 等待任务完成,在get方法中最后会调用到这里
  293. */
  294. private int awaitDone(boolean timed, long nanos)
  295. throws InterruptedException {
  296. //计算一下需要等待的时间,有可能为0,为0的话就无限期等待。
  297. final long deadline = timed ? System.nanoTime() + nanos : 0L;
  298. //一个等待节点
  299. WaitNode q = null;
  300. //是否加入队列
  301. boolean queued = false;
  302. for (;;) {
  303. //如果当且调用get方法的线程被interrupt 那么就把当前线程从等待队列remove
  304. //然后抛出异常
  305. if (Thread.interrupted()) {
  306. removeWaiter(q);
  307. throw new InterruptedException();
  308. }
  309. int s = state;
  310. //如果任务已经完成 不管是被暂停了 还是出现异常了 只要状态大于COMPLETING就返回。
  311. if (s > COMPLETING) {
  312. if (q != null)
  313. q.thread = null;
  314. return s;
  315. }
  316. else if (s == COMPLETING) // cannot time out yet
  317. //如果任务正在完成中(注意是ING进行时) 那么让出一会CPU时间在继续执行
  318. Thread.yield();
  319. else if (q == null)
  320. //创建等待节点
  321. q = new WaitNode();
  322. else if (!queued)
  323. //第一次创建的等待节点需要加入等待队列,这里加入队列等待。
  324. queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
  325. q.next = waiters, q);
  326. else if (timed) {
  327. //如果设置了等待 那么就得锁住线程等待,如果时间到了就返回状态。
  328. //方法 public V get(long timeout, TimeUnit unit) 这里会根据状态做后续处理。
  329. nanos = deadline - System.nanoTime();
  330. if (nanos <= 0L) {
  331. removeWaiter(q);
  332. return state;
  333. }
  334. LockSupport.parkNanos(this, nanos);
  335. }
  336. else
  337. //否则锁住线程等待其他线程解锁。
  338. LockSupport.park(this);
  339. }
  340. }
  341.  
  342. /**
  343. * 这里就是循环线程队列,将当前等待节点remove掉
  344. */
  345. private void removeWaiter(WaitNode node) {
  346. if (node != null) {
  347. node.thread = null;
  348. retry:
  349. for (;;) { // restart on removeWaiter race
  350. for (WaitNode pred = null, q = waiters, s; q != null; q = s) {
  351. s = q.next;
  352. if (q.thread != null)
  353. pred = q;
  354. else if (pred != null) {
  355. pred.next = s;
  356. if (pred.thread == null) // check for race
  357. continue retry;
  358. }
  359. else if (!UNSAFE.compareAndSwapObject(this, waitersOffset,
  360. q, s))
  361. continue retry;
  362. }
  363. break;
  364. }
  365. }
  366. }
  367.  
  368. // Unsafe mechanics
  369. private static final sun.misc.Unsafe UNSAFE;
  370. private static final long stateOffset;
  371. private static final long runnerOffset;
  372. private static final long waitersOffset;
  373. static {
  374. try {
  375. UNSAFE = sun.misc.Unsafe.getUnsafe();
  376. Class<?> k = FutureTask.class;
  377. stateOffset = UNSAFE.objectFieldOffset
  378. (k.getDeclaredField("state"));
  379. runnerOffset = UNSAFE.objectFieldOffset
  380. (k.getDeclaredField("runner"));
  381. waitersOffset = UNSAFE.objectFieldOffset
  382. (k.getDeclaredField("waiters"));
  383. } catch (Exception e) {
  384. throw new Error(e);
  385. }
  386. }
  387.  
  388. }

由此可见此类的设计还是非常复杂的,不得不佩服老外们的逻辑思维能力,相当的缜密,上面一些关于状态的转换过程还是比较复杂的,

因为要考虑到多线程的情况,还要考虑到状态转换时的线程安全问题等等。具体奥妙还的自己分析源码慢慢体会。

Java FutureTask<V> 源码分析 Android上的实现的更多相关文章

  1. 细说并发4:Java 阻塞队列源码分析(上)

    上篇文章 趣谈并发3:线程池的使用与执行流程 中我们了解到,线程池中需要使用阻塞队列来保存待执行的任务.这篇文章我们来详细了解下 Java 中的阻塞队列究竟是什么. 读完你将了解: 什么是阻塞队列 七 ...

  2. 细说并发5:Java 阻塞队列源码分析(下)

    上一篇 细说并发4:Java 阻塞队列源码分析(上) 我们了解了 ArrayBlockingQueue, LinkedBlockingQueue 和 PriorityBlockingQueue,这篇文 ...

  3. 【JAVA】ThreadLocal源码分析

    ThreadLocal内部是用一张哈希表来存储: static class ThreadLocalMap { static class Entry extends WeakReference<T ...

  4. 【Java】HashMap源码分析——常用方法详解

    上一篇介绍了HashMap的基本概念,这一篇着重介绍HasHMap中的一些常用方法:put()get()**resize()** 首先介绍resize()这个方法,在我看来这是HashMap中一个非常 ...

  5. 【Java】HashMap源码分析——基本概念

    在JDK1.8后,对HashMap源码进行了更改,引入了红黑树.在这之前,HashMap实际上就是就是数组+链表的结构,由于HashMap是一张哈希表,其会产生哈希冲突,为了解决哈希冲突,HashMa ...

  6. Tomcat处理HTTP请求源码分析(上)

    Tomcat处理HTTP请求源码分析(上) 作者 张华 发布于 2011年12月8日 | 8 讨论 分享到: 微博 微信 Facebook Twitter 有道云笔记 邮件分享 稍后阅读 我的阅读清单 ...

  7. Java split方法源码分析

    Java split方法源码分析 public String[] split(CharSequence input [, int limit]) { int index = 0; // 指针 bool ...

  8. 源码分析Android Handler是如何实现线程间通信的

    源码分析Android Handler是如何实现线程间通信的 Handler作为Android消息通信的基础,它的使用是每一个开发者都必须掌握的.开发者从一开始就被告知必须在主线程中进行UI操作.但H ...

  9. Java并发包源码分析

    并发是一种能并行运行多个程序或并行运行一个程序中多个部分的能力.如果程序中一个耗时的任务能以异步或并行的方式运行,那么整个程序的吞吐量和可交互性将大大改善.现代的PC都有多个CPU或一个CPU中有多个 ...

随机推荐

  1. docker 和 vagrant 作为程序发布 和 开发的独立而统一的运行环境

    docker 和 vagrant 作为程序发布 和 开发的运行环境,可以提供打包程序,并使得程序运行在一个独立的虚拟环境中,避免程序发布到客户机之后,环境不一致导致的诸多问题.     refer: ...

  2. [转]PostgreSQL教程(十六):系统视图详解

    这篇文章主要介绍了PostgreSQL教程(十六):系统视图详解,本文讲解了pg_tables.pg_indexes.pg_views.pg_user.pg_roles.pg_rules.pg_set ...

  3. HTTP 请求头 详解

    转载:https://kb.cnblogs.com/page/92320/ HTTP(HyperTextTransferProtocol)即超文本传输协议,目前网页传输的的通用协议.HTTP协议采用了 ...

  4. mysql-8.0.11 比较坑的地方dba门要淡定

    [事件描述] 突然之间大量的连接进入数据库.并放开手干,这个使得mysql使用了大量的内存,触发了linux的oom机制.然后mysql就这样 被linux给干掉了.没错MySQL宕机了,要相信我说的 ...

  5. Windows系统创建符号链接文件

    源文件夹:E:\深海 创建新硬链接文件夹:D:\微云同步盘\719179409\4-工作资料\深海   使用快捷键Win + X 打开以下菜单,选择命令提示符(管理员) 敲入以下命令:   创建成功后 ...

  6. 如何安全的下载Devcon.exe文件

    devcon.exe是windows设备管理器的命令行版本,可以让你在cmd中修改设备,但是微软没有提供单独的下载,只能下载一个2G多的wdk包(windows drive kits)才行.私下使用别 ...

  7. Atitit 图像处理类库安装与安装模式的前世今生与未来大趋势attilax总结.docx

    Atitit 图像处理类库安装与安装模式的前世今生与未来大趋势attilax总结.docx 1. 安装的原理,主要是解压,复制,设置三大步1 2. 目前我们常见的三大种安装模式,二进制模式与源码安装模 ...

  8. 【Unity】2.6 游戏视图(Game)

    分类:Unity.C#.VS2015 创建日期:2016-03-29 一.简介 游戏视图 (Game View) 从游戏的相机 ((Camera(s)) 中呈现,代表所发布游戏的最终版.你将需要一台或 ...

  9. C语言:存取结构体成员的点运算符(.)和箭头运算符(->)的区别

    转自:http://blog.csdn.net/taric_ma/article/details/7397362 一直以为这两个是没有什么区别的,可以相互替换,今天又翻了一下<C语言核心技术&g ...

  10. 【006】【JVM——垃圾收集器总结】

     Java虚拟机学习总结文件夹 JVM--垃圾收集器总结 垃圾收集器概览 收集算法是内存回收的方法论.垃圾收集据是内存回收的详细实现.Java虚拟机规范中对垃圾收集器应该怎样实现没有规定.不同的厂 ...