上一篇文章中,主要介绍了AbstractExecutorService的线程执行的核心流程,execute() 这个方法显然是没有返回执行任务的结果,如果我们需要获取任务执行的结果,怎么办?
Callable 就是一个可以获取线程执行的结果。
public abstract class AbstractExecutorService implements ExecutorService {
/*
* 将任务包装成FutureTask任务。带返回值参数的
*/
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new FutureTask<T>(runnable, value);
}
/**
** 不带返回值的
**/
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
return new FutureTask<T>(callable);
}
/**
* @throws RejectedExecutionException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
//1.将任务包装成RunableFuture对象,由于RunnableFuture是实现Runable类,所以execute的参数是一个可拓展的类型
RunnableFuture<Void> ftask = newTaskFor(task, null);
//2,交给具体的执行器进行实现
execute(ftask);
return ftask;
}
/**
* @throws RejectedExecutionException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
public <T> Future<T> submit(Runnable task, T result) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task, result);
execute(ftask);
return ftask;
}
/**
* @throws RejectedExecutionException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
//将任务装成成一个FutureTask任务
RunnableFuture<T> ftask = newTaskFor(task);
//执行任务
execute(ftask);
return ftask;
}
}
submit其实是一个重载的方法,分别是一个task,以及可以传递获取结果的任务,以及使用callable。
从源码上看三个方法其实都是将任务进行了封装,然后调用线程池执行的核心方法
public static void main(String[] args) throws ExecutionException, InterruptedException {
Callable<Integer> resultCallable = new Callable<Integer>() {
@Override
public Integer call() throws Exception {
return 1 + 1;
}
};
ExecutorService threadPool = Executors.newFixedThreadPool(1);
Future<Integer> resultTask = threadPool.submit(resultCallable);
System.out.println(resultTask.get());
threadPool.shutdown();
}
public class FutureTask<V> implements RunnableFuture<V> {
/* 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; // 任务正常完成,结果被set
private static final int EXCEPTIONAL = 3; // 任务抛出异常
private static final int CANCELLED = 4; // 任务被取消
private static final int INTERRUPTING = 5; // 线程中断状态被设置为true 线程未响应中断
private static final int INTERRUPTED = 6; // 线程已被中断
/** The underlying callable; nulled out after running */
private Callable<V> callable; // 需要执行的任务
/** The result to return or exception to throw from get() */
// 执行callable的线程,调用FutureTask.run()方法通过CAS设置
private Object outcome; // non-volatile, protected by state reads/writes
/** The thread running the callable; CASed during run() */
// 执行callable的线程,调用FutureTask.run()方法通过CAS设置
private volatile Thread runner;
/** Treiber stack of waiting threads */
private volatile WaitNode waiters;
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // 初始化状态是new // ensure visibility of callable
}
}
/* 继承了Runnable ,因为线程池中执行的也是Runnbale的任务
*/
public interface RunnableFuture<V> extends Runnable, Future<V> {
/**
* Sets this Future to the result of its computation
* unless it has been cancelled.
*/
void run();
}
FutureTask 实现RunnableFuture,也间接实现了run方法。
重点
我们知道 execute(ftask); 本质就是利用线程池进行执行,而线程执行的时候,其实就是启动对应任务的run方法。
task.run();
// 这里是什么时候调用的,其实是
// execute(ftask)传入的任务 task.run()
public void run() {
//不是新建状态 直接中止
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 {
//核心,执行任务的call方法,你看就是调用普通的方法一样。
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);
}
}
protected void set(V v) {
//CAS 去设置当前任务执行状态 new-completing
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
//返回结果outcome
outcome = v;
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
finishCompletion();
}
}
public V get() throws InterruptedException, ExecutionException {
int s = state;
//如果是在执行中,则等待一会
if (s <= COMPLETING)
s = awaitDone(false, 0L);
//返回结果
return report(s);
}
/**
* @throws CancellationException {@inheritDoc}
*/
public V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
if (unit == null)
throw new NullPointerException();
//设置了超时时间,则等待一定的时间,如果还没有获取到返回异常
int s = state;
if (s <= COMPLETING &&
(s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
throw new TimeoutException();
return report(s);
}
private V report(int s) throws ExecutionException {
Object x = outcome;
//执行完成 返回x结果
if (s == NORMAL)
return (V)x;
//如果任务取消,返回异常
if (s >= CANCELLED)
throw new CancellationException();
throw new ExecutionException((Throwable)x);
}
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
final long deadline = timed ? System.nanoTime() + nanos : 0L;
WaitNode q = null;
boolean queued = false;
for (;;) {
//如果线程执行interrupted,直接抛出异常,并且将任务移除
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
Thread.yield();
else if (q == null)
q = new WaitNode();
else if (!queued)
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);
}
}
FutureTask是一个支持取消行为的异步任务执行器。该类实现了Future接口的方法。
如:
如果在当前线程中需要执行比较耗时的操作,但又不想阻塞当前线程时,可以把这些作业交给FutureTask,另开一个线程在后台完成,当当前线程将来需要时,就可以通过FutureTask对象获得后台作业的计算结果或者执行状态。
Future模式其实是多线程编程中常用的设计模式,主线程向另外一个线程提交任务,无需等待任务执行的结果,返回一个凭证,就是future,通过future.get()去获取结果。这个过程可能是阻塞的。