一、FutureTask及Future的使用
一个可取消的异步计算,FutureTask提供了对Future的基本实现,可以调用方法去开始和取消一个计算,可以查询计算是否完成,可以获取异步计算的结果。
1、基本使用方式一
// FutureTask需要一个Callable对象
FutureTask<String> task = new FutureTask<>(new Callable<String>() {
@Override
public String call() throws Exception {
Thread.sleep(5000);
return "ABC";
}
});
// 把FutureTask交给线程并开启即可
Thread thread = new Thread(task);
thread.start();
System.out.println("====thread start====");
try {
// 获取计算结果,这个方法会阻塞当前线程的,直到结果返回为止
String result = task.get();
System.out.println("===" + result + "===");
} catch (Exception e) {
}
2、基本使用方式一
// 通过线程池的形式,提交一个Callable对象
ExecutorService executorService = Executors.newCachedThreadPool();
Future<String> future = executorService.submit(new Callable<String>() {
@Override
public String call() throws Exception {
Thread.sleep(5000);
return "ABC";
}
});
try {
// 获取计算结果,这个方法会阻塞当前线程的,直到结果返回为止
String result = future.get();
System.out.println("===" + result + "===");
} catch (Exception e) {
}
3、源码分析
/**
* 定义了一个接口
*/
public interface Callable<V> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}
/**
* Future同样是一个接口
*/
public interface Future<V> {
// 调用该方法即可以取消任务的执行。如果子任务还未开始执行,那么调用该
// 方法子任务会被取消不会被执行。如果子任务正在执行中,就分两种情况,
// 情况1是mayInterruptIfRunning=true,那么会中断任务的线程,并返回true
// 情况2是mayInterruptIfRunning=false,不会中断任务的线程,但是还是会返回true
// 如果子任务已执行结束或已被取消,就会返回false
boolean cancel(boolean mayInterruptIfRunning);
// 判断任务是否已取消
boolean isCancelled();
// 判断任务是否已结束,正常执行结束,或者发生异常结束,或者被取消,都属于结束
boolean isDone();
// 获取计算结果或者说子任务线程的返回结果
V get() throws InterruptedException, ExecutionException;
// 同上,因为这个方法会阻塞线程,参数的意思就表示最多阻塞多久就不再阻塞了。
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
/**
* FutureTask继承的接口RunnableFuture,相当于多封装一层,
* 这个接口既继承了Runnable,也继承了Future
*/
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类
*/
public class FutureTask<V> implements RunnableFuture<V> {
// 状态变化有如下4种情况:
// NEW -> COMPLETING -> NORMAL --------------------------------------- 正常执行结束的流程
// NEW -> COMPLETING -> EXCEPTIONAL ---------------------执行过程中出现异常的流程
// NEW -> CANCELLED -------------------------------------------被取消,即调用了cancel(false)
// NEW -> INTERRUPTING -> INTERRUPTED -------------被中断,即调用了cancel(true)
private volatile int state;
// 默认的原始状态
private static final int NEW = 0;
// 表示任务执行结束(正常执行结束,或者发生异常结束),但是还没有将结果保存到outcome中。是一个中间状态。
private static final int COMPLETING = 1;
// 表示任务正常执行结束,并且已经把执行结果保存到outcome字段中。是一个最终状态。
private static final int NORMAL = 2;
// 表示任务发生异常结束,异常信息已经保存到outcome中,这是一个最终状态。
private static final int EXCEPTIONAL = 3;
// 任务在执行结束之前被取消了,但是不要求中断正在执行的线程,也就是调用了cancel(false)
private static final int CANCELLED = 4;
// 任务在执行结束之前被取消了,并要求中断线程的执行,也就是调用了cancel(true)
private static final int INTERRUPTING = 5;
// 调用cancel(true)取消异步任务,会调用interrupt()中断线程的执行,然后状态会从INTERRUPTING变到INTERRUPTED。
private static final int INTERRUPTED = 6;
/**
* 构造方法,需要一个callable对象
*/
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
/**
* 交由线程后,会执行这个方法
*/
public void run() {
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
// 直接调用Callable的call方法,获取结果
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
// 把结果存储到变量outcome中
if (ran)
set(result);
}
} finally {
runner = null;
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
/**
* 获取结果的get方法,该方法会阻塞线程
*/
public V get() throws InterruptedException, ExecutionException {
int s = state;
if (s <= COMPLETING)
s = awaitDone(false, 0L);
return report(s);
}
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
long startTime = 0L;
WaitNode q = null;
boolean queued = false;
for (;;) {
//1. 读取状态
//1.1 如果s > COMPLETING,表示任务已经执行结束,
// 或者发生异常结束了,就不会阻塞,直接返回
int s = state;
if (s > COMPLETING) {
if (q != null)
q.thread = null;
return s;
}
//1.2 如果s == COMPLETING,表示任务结束(正常/异常),
//但是结果还没有保存到outcome字段,当前线程让出执行权,给其他线程先执行
else if (s == COMPLETING)
// We may have already promised (via isDone) that we are done
// so never return empty-handed or throw InterruptedException
Thread.yield();
//2. 如果调用get()的线程被中断了,就从等待的线程栈中移除
//这个等待节点,然后抛出中断异常
else if (Thread.interrupted()) {
removeWaiter(q);
throw new InterruptedException();
}
//3. 如果等待节点q=null,就创建一个等待节点
else if (q == null) {
if (timed && nanos <= 0L)
return s;
q = new WaitNode();
}
//4. 如果这个等待节点还没有加入等待队列,就加入队列头
else if (!queued)
queued = U.compareAndSwapObject(this, WAITERS,
q.next = waiters, q);
//5. 如果设置了超时等待时间
else if (timed) {
//5.1 设置startTime,用于计算超时时间,如果超时时间到了,就等待队列中移除当前节点
final long parkNanos;
if (startTime == 0L) { // first time
startTime = System.nanoTime();
if (startTime == 0L)
startTime = 1L;
parkNanos = nanos;
} else {
long elapsed = System.nanoTime() - startTime;
if (elapsed >= nanos) {
removeWaiter(q);
return state;
}
parkNanos = nanos - elapsed;
}
// nanoTime may be slow; recheck before parking
//5.2 如果超时时间还没有到,而且任务还没有结束,就阻塞特定时间
if (state < COMPLETING)
LockSupport.parkNanos(this, parkNanos);
}
//6. 阻塞,等待唤醒
else
// LockSupport就是一个提供阻塞线程方法的工具类
LockSupport.park(this);
}
}
}
二、AsyncTask源码
1、构造方法
public AsyncTask(@Nullable Looper callbackLooper) {
// 初始化Handler
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
// 其实是Callable
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Result result = null;
try {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
// AsyncTask里重写的doInBackground
result = doInBackground(mParams);
Binder.flushPendingCommands();
} catch (Throwable tr) {
mCancelled.set(true);
throw tr;
} finally {
// 最终会执行这个方法
postResult(result);
}
return result;
}
};
// 初始化FutureTask
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
try {
postResultIfNotInvoked(get());
} catch (InterruptedException e) {
android.util.Log.w(LOG_TAG, e);
} catch (ExecutionException e) {
throw new RuntimeException("An error occurred while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
}
/**
* WorkerRunnable其实就是一个Callable,多了个变量mParams
*/
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
/*
* postResult方法会通过主线程的Handler把消息发出去
*/
private Result postResult(Result result) {
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
private static class InternalHandler extends Handler {
public InternalHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
// 上面发送的消息会来到这里,调用下方的finish方法
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
// 调用我们重写的onPostExecute方法
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
2、execute开启AsyncTask执行
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
// 其实sDefaultExecutor是一个默认的线程池,并且是静态的,即所有的AsyncTask对象都公用一个默认的线程池
// 等下再展示sDefaultExecutor的代码
return executeOnExecutor(sDefaultExecutor, params);
}
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
mStatus = Status.RUNNING;
// 回调onPreExecute
onPreExecute();
// 保存params到Callable的子类,即WorkerRunnable
mWorker.mParams = params;
// 调用线程池的execute方法,即子类sDefaultExecutor的execute方法
exec.execute(mFuture);
return this;
}
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static class SerialExecutor implements Executor {
// mTasks是一个双向队列
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
// 这个方法即上面调用执行的execute方法,r即是我们的FutureTask
// synchronized同步,保证串行
public synchronized void execute(final Runnable r) {
// 添加到队列的头部
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
// 把下一个Runnable拿出来并执行
// mTasks.poll会从队列里移除,并移除的值返回
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
// THREAD_POOL_EXECUTOR = ThreadPoolExecutor
// THREAD_POOL_EXECUTOR实际上是1个已配置好的可执行并行任务的线程池
THREAD_POOL_EXECUTOR.execute(mActive);
// 调用后会执行mActive的Run方法,而上面的run方法会调用r.run();
// 即调用mFutureTask的run()方法,熟悉FutureTask的都知道,最终会调用Callable的call方法
// 最终去到构造方法里的mWorkRunnable
}
}
}
通过上面的分析可以得出以下结论:
(1)AsyncTask内部有两个线程池,sDefaultExecutor = SerialExecutor,该线程池的作用是任务调度,让多个AsyncTask任务按顺序执行,即串行。另外一个是THREAD_POOL_EXECUTOR是我们doInBackground执行的真正线程池。
(2)线程执行完毕后,依然是通过Handler发送消息给主线程去执行onPostExecute。
(3)调用executeOnExecutor时,我们可以传入自定义的线程池,那么就不会使用AsyncTask默认的sDefaultExecutor了。