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

首先看一下继承关系

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

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

public interface Future<V> {

    //试图取消对此任务的执行。
boolean cancel(boolean mayInterruptIfRunning); //如果在任务正常完成前将其取消,则返回 true。
boolean isCancelled(); //如果任务已完成,则返回 true。
boolean isDone(); //如有必要,等待计算完成,然后获取其结果。
V get() throws InterruptedException, ExecutionException; //如有必要,最多等待为使计算完成所给定的时间之后,获取其结果(如果结果可用)。
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}

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

 public class FutureTask<V> implements RunnableFuture<V> {

     /**
* 这个类可能的几种过度状态
* NEW -> COMPLETING -> NORMAL 新建-正在完成-正常完成
* NEW -> COMPLETING -> EXCEPTIONAL 新建-正在完成-异常
* NEW -> CANCELLED 新建-取消
* NEW -> INTERRUPTING -> INTERRUPTED 新建-正在中断线程-已经中断
*/
private volatile int state; //当前状态 注意volatile,因为这个类是为多线程使用而设计的
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; /** 用于执行任务并且返回结果 */
private Callable<V> callable;
/** 用于存放返回结果 另外如果出现异常那么就存放异常的引用 */
private Object outcome; // non-volatile, protected by state reads/writes
/** 当前执行该类的线程 */
private volatile Thread runner;
/** 等待锁队节点 */
private volatile WaitNode waiters; /**
* 根据state的值,判断任务是否正常完成。
*
* @param s 当前的状态值
*/
@SuppressWarnings("unchecked")
private V report(int s) throws ExecutionException {
Object x = outcome;
//如果状态为NORMAL 则正常返回结果。
if (s == NORMAL)
return (V)x;
//如果状态>=CANCELLED 则抛出一个异常CancellationException 告诉用户任务已经终止。
if (s >= CANCELLED)
throw new CancellationException();
//否则就是任务执行过程中出现异常,包装一下直接抛出。
throw new ExecutionException((Throwable)x);
} /**
* 构造参数 传入callable对象,并且将当前状态state设置为null。
*/
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
} /**
* 传入runnable对象和result
* 通过Executors包装一下,还是返回一个callable的实例
* 在执行完runnable的任务后直接返回result
*/
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
} /*
* 判断任务是否取消
*/
public boolean isCancelled() {
return state >= CANCELLED;
} /*
* 如果任务已完成,则返回 true。
* 可能由于正常终止、异常或取消而完成,在所有这些情况中,此方法都将返回 true。
*/
public boolean isDone() {
return state != NEW;
} /**
* 取消任务
* mayInterruptIfRunning 如果应该中断执行此任务的线程,则为 true;否则允许正在运行的任务运行完成
*/
public boolean cancel(boolean mayInterruptIfRunning) {
//如果当前状态不是新创建时的状态 那么返回false
//这种情况说明任务已经执行,那么当前状态的值就有俩种情况。
//一种是任务正常完成 那么当前状态将的值会按照这个方向执行 NEW -> COMPLETING -> NORMAL
//一种任务是执行中出现异常 那么当前状态的值会按照这个方向执行 NEW -> COMPLETING -> EXCEPTIONAL
if (state != NEW)
return false; if (mayInterruptIfRunning) {
//设置当前状态为INTERRUPTING(正在设置线程的中断状态)
if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, INTERRUPTING))
return false;
Thread t = runner;
if (t != null)
//设置线程的中断状态
t.interrupt();
//设置当前状态为INTERRUPTED
UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED); // final state
}
//如果当前状态为NEW 那么会把当前状态设置为 CANCELLED 然后调用finishCompletion,然后返回成功
else if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, CANCELLED))
return false;
//这个方法下面解释
finishCompletion();
return true;
} /**
* 获取任务的结果,如果任务未完成则线程进入等待状态。
*/
public V get() throws InterruptedException, ExecutionException {
int s = state;
//如果任务未完成
if (s <= COMPLETING)
//等待完成 里面的是实现是等待队列
s = awaitDone(false, 0L);
//调用report方法来根据情况返回结果
return report(s);
} /**
* 最多等待为使计算完成所给定的时间之后,获取其结果。
*/
public V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
if (unit == null)
throw new NullPointerException();
int s = state;
//如果超时任务未能完成就抛出TimeoutException
if (s <= COMPLETING &&
(s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
throw new TimeoutException();
//调用report方法来根据情况返回结果
return report(s);
} /**
* 给子类扩展的方法,state状态发生改变时被调用。
*/
protected void done() { } protected void set(V v) {
//将状态先设置为COMPLETING正在完成,然后再设置为正常NORMAL
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
//然后调用完成方法
finishCompletion();
}
} protected void setException(Throwable t) {
//将状态先设置为COMPLETING正在完成,然后再设置为异常EXCEPTIONAL
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = t;
UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
//然后调用完成方法
finishCompletion();
}
} //任务开始方法
public void run() {
//任务不能多个线程同时运行。
//如果第一次运行将runner设置为当前执行的线程。
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
//任务正常完成 也就是没有出现异常,那么ran=true
ran = true;
} catch (Throwable ex) {
//出现异常就调用setException方法,将状态state设置为EXCEPTIONAL
result = null;
ran = false;
setException(ex);
}
//如果上面任务正常完成则调用set方法,那么将状态state设置为NORMAL
if (ran)
set(result);
}
} finally {
runner = null;
int s = state;
//这里要判断一下,任务是否被取消过。
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
} /**
* Executes the computation without setting its result, and then
* resets this future to initial state, failing to do so if the
* computation encounters an exception or is cancelled. This is
* designed for use with tasks that intrinsically execute more
* than once.
*
* @return true if successfully run and reset
*/
protected boolean runAndReset() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return false;
boolean ran = false;
int s = state;
try {
Callable<V> c = callable;
if (c != null && s == NEW) {
try {
c.call(); // don't set result
ran = true;
} catch (Throwable ex) {
setException(ex);
}
}
} 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
s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
return ran && s == NEW;
} /**
* 如果其他线程正在中午该任务,那么运行该任务的线程就暂时让出CPU时间
* 一直到state=INTERRUPTED为止。
*/
private void handlePossibleCancellationInterrupt(int s) { if (s == INTERRUPTING)
while (state == INTERRUPTING)
Thread.yield(); // wait out pending interrupt
} /**
* Simple linked list nodes to record waiting threads in a Treiber
* stack. See other classes such as Phaser and SynchronousQueue
* for more detailed explanation.
*/
static final class WaitNode {
volatile Thread thread;
volatile WaitNode next;
WaitNode() { thread = Thread.currentThread(); }
} /**
* 解锁所有等待队列当中的线程,让他们调用done方法。
*/
private void finishCompletion() {
// assert state > COMPLETING;
for (WaitNode q; (q = waiters) != null;) {
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
for (;;) {
Thread t = q.thread;
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
} /**
* 等待任务完成,在get方法中最后会调用到这里
*/
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
//计算一下需要等待的时间,有可能为0,为0的话就无限期等待。
final long deadline = timed ? System.nanoTime() + nanos : 0L;
//一个等待节点
WaitNode q = null;
//是否加入队列
boolean queued = false;
for (;;) {
//如果当且调用get方法的线程被interrupt 那么就把当前线程从等待队列remove
//然后抛出异常
if (Thread.interrupted()) {
removeWaiter(q);
throw new InterruptedException();
}
int s = state;
//如果任务已经完成 不管是被暂停了 还是出现异常了 只要状态大于COMPLETING就返回。
if (s > COMPLETING) {
if (q != null)
q.thread = null;
return s;
}
else if (s == COMPLETING) // cannot time out yet
//如果任务正在完成中(注意是ING进行时) 那么让出一会CPU时间在继续执行
Thread.yield();
else if (q == null)
//创建等待节点
q = new WaitNode();
else if (!queued)
//第一次创建的等待节点需要加入等待队列,这里加入队列等待。
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
else if (timed) {
//如果设置了等待 那么就得锁住线程等待,如果时间到了就返回状态。
//方法 public V get(long timeout, TimeUnit unit) 这里会根据状态做后续处理。
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {
removeWaiter(q);
return state;
}
LockSupport.parkNanos(this, nanos);
}
else
//否则锁住线程等待其他线程解锁。
LockSupport.park(this);
}
} /**
* 这里就是循环线程队列,将当前等待节点remove掉
*/
private void removeWaiter(WaitNode node) {
if (node != null) {
node.thread = null;
retry:
for (;;) { // restart on removeWaiter race
for (WaitNode pred = null, q = waiters, s; q != null; q = s) {
s = q.next;
if (q.thread != null)
pred = q;
else if (pred != null) {
pred.next = s;
if (pred.thread == null) // check for race
continue retry;
}
else if (!UNSAFE.compareAndSwapObject(this, waitersOffset,
q, s))
continue retry;
}
break;
}
}
} // Unsafe mechanics
private static final sun.misc.Unsafe UNSAFE;
private static final long stateOffset;
private static final long runnerOffset;
private static final long waitersOffset;
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);
}
} }

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

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

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. DLL注入

    最近的项目涉及了软件破解方面的知识,记录一下. 将dll注入另一个进程. // Inject.cpp : Defines the exported functions for the DLL appl ...

  2. 全栈必备 Linux 基础

    Linux 几乎无处不在,不论是服务器构建,还是客户端开发,操作系统的基础技能对全栈来说都是必备的.系统的选择Linux发行版本可以大体分为两类,一类是商业公司维护的发行版本,一类是社区组织维护的发行 ...

  3. 洛谷 P1305 新二叉树 Label:字符串的输出总是有惊喜

    题目描述 输入一串完全二叉树,用遍历前序打出. 输入输出格式 输入格式: 第一行为二叉树的节点数n. 后面n行,每一个字母为节点,后两个字母分别为其左右儿子. 空节点用*表示 输出格式: 前序排列的完 ...

  4. Linux network setting.

    Lubuntu network setting. //1. Vi /etc/network/interfaces Add:auto eth0iface eth0 inet dhcp //2. Vi / ...

  5. Linux 0.12 内核管理存储器

    Linux 0.12 内核管理存储器 其分段,用分段的机制把进程间的虚拟地址分隔开. 每一个进程都有一张段表LDT.整个系统有一张GDT表.且整个系统仅仅有一个总页表. 其地址翻译过程为: 程序中给出 ...

  6. SOD框架--系统概要

    SOD框架(源PDF.NETE框架)系统概要介绍 --核心三大功能(S,O,D): SQL-MAP XML SQL config and Map DAL SQL Map Entity ORM OQL( ...

  7. JavaScript控制阻止表单提交

    1.在表单上使用onSubmit方法 <?php $form = ActiveForm::begin([ 'options'=>[ 'class' => 'form-horizont ...

  8. C# 设置Excel数字格式

    数字格式使指能够控制Excel单元格中数字如何显示的格式字符串.例如,我们可以对数字12345应用数字格式“0.00”,使之显示为“12345.00”.在例如对数字12345应用“¥0.00”格式,使 ...

  9. 【转】联想笔记本进入u盘启动项操作方法详解

    win7之家小编最近可是对联想笔记本进入u盘启动项的方法很有兴趣啊,那么联想进入u盘启动到底要怎么操作呢?其实方法是有的,因为小编就是研究联想进入u盘启动出身的,下面小编就给大家带来史上最详细的联想笔 ...

  10. 获取 ip ( 第三方接口 )

    搜狐IP地址查询接口(默认GBK):http://pv.sohu.com/cityjson 搜狐IP地址查询接口(可设置编码):http://pv.sohu.com/cityjson?ie=utf-8 ...