本文深入探讨了Android中的AsyncTask源码，包括其execute方法逻辑、内部使用的串行线程池、Callable与FutureTask的关系。讲解了Future接口的get()方法如何阻塞等待任务完成，以及cancel()方法用于停止任务。同时，分析了FutureTask的done()回调方法在避免阻塞UI线程中的作用。最后，解释了AsyncTask如何通过FutureTask实例在后台执行Callable的call()方法，并传递结果。
虽然AsyncTask现在用的很少，但是面试的时候还是会被问到，所以是时间好好研究一下AsyncTask的源码了
首先来看一下execute方法的逻辑:
AsyncTask
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}@MainThread可以看出来execute方法只能在主线程中被调用，另外execute方法会调用executeOnExecutor方法
并且传入一个串行的线程池对象，我们看一下AsyncTask中的串行线程池是如何实现的（从AsyncTask中抽离出来）
public abstract class AsyncTask<Params, Progress, Result> {
private static final String LOG_TAG = "AsyncTask";
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;//核心线程数量为CPU数量+1
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE = 1;
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable r) {
//ThreadFactory创建线程,mCount.getAndIncrement()的时候实现数字自增长1
//作用跟i++的作用是一样的,不错i++是非线程安全的,多个线程同时操作时会造成数据错误
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
}
};
//一个指定容量大小为128的LinkedBlockingQueue阻塞队列
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
private static class SerialExecutor implements Executor {
//一个两端队列
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
//这里有两个疑问点需要注意一下
//1,为什么不直接把r offer到队列?因为需要在当前加入的线程执行完成后再去调用scheduleNext()方法
//所以套了一层Runnable,从而实现线程池的串行
//2.为什么调用r.run()而不调用r.start()?run()和start()方法同样会执行run方法中的逻辑
//但是start()方法的run方法执行在子线程,r.run方法执行在当前线程,如果调用start方法,则会在一个子线程中再开启一个子线程,而run不会
r.run();
} finally {
scheduleNext();
}
}
});
//第一次,需要手动调用scheduleNext()方法
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
//从队列中取一个头元素,不为空则放到THREAD_POOL_EXECUTOR线程池
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
}不多解析，注释都写的很清楚了，下面来看一下executeOnexecTor方法
@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
if (mStatus != Status.PENDING) {
switch (mStatus) {
case RUNNING:
throw new IllegalStateException("Cannot execute task:"
+ " the task is already running.");
case FINISHED:
throw new IllegalStateException("Cannot execute task:"
+ " the task has already been executed "
+ "(a task can be executed only once)");
}
}
mStatus = Status.RUNNING;
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}前面几个状态的判断可以看出AsyncTask一个任务实例只能执行一次，如果执行第二次将会抛出异常
该方法中会先调用onPreExecute()，然后将FutureTask对象提交任务到串行的线程池，接下来我们来看看WorkerRunnable
和FutureTask是什么东西，WorkerRunnable是Callable接口的一个实现类，FutureTask实现了Runnable和Future接口
我们首先来看看Future接口
Future
public interface Future<V> {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}Future是一个接口，他提供给了我们方法来检测当前的任务是否已经结束，还可以等待任务结束并且拿到一个结
果，通过调用Future的get（）方法可以当任务结束后返回一个结果值，如果工作没有结束，则会阻塞当前线程，直到
任务执行完毕，我们可以通过调用cancel（）方法来停止一个任务，如果任务已经停止，则cancel（）方法会返回
true；如果任务已经完成或者已经停止了或者这个任务无法停止，则cancel（）会返回一个false。当一个任务被成功
停止后，他无法再次执行。isDone（）和isCancel（）方法可以判断当前工作是否完成和是否取消。
那么这个Future究竟该怎么用呢？我们看到线程池还有一个方法可以执行一个任务，那就是submit（）方法
public Future<?> submit(Runnable task) {
return e.submit(task);
}
的对象是什么类型，那么就返回一个null好了，因为我们执行的是一个Runnable对象，Runnable是没有返回值的，所
以这里用一个问号，说明没有返回值，那么就返回一个null好了。
public class ExecutorDemo {
public static void main(String[] args) {
ExecutorService es = Executors.newSingleThreadExecutor();
CountRunnable work = new CountRunnable();
Future<?> future = es.submit(work);
System.out.println("任务开始于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
for(int i=0 ; i<10 ; i++){
try {
TimeUnit.SECONDS.sleep(1);
System.out.println("主线程"+Thread.currentThread().getName()+"仍然可以执行");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Object object = future.get();
System.out.println("任务结束于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+" result="+object);
} catch (Exception e) {
e.printStackTrace();
}
es.shutdown();
System.out.println("关闭线程池"+es.isShutdown());
}
public static class CountRunnable implements Runnable{
private int sum;
@Override
public void run() {
for(int i=1 ; i<11 ; i++){
try {
TimeUnit.MILLISECONDS.sleep(1000);
sum+=i;
System.out.println("工作线程"+Thread.currentThread().getName()+"正在执行 sum="+sum);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
我们看到Future有一个get（）方法，这个方法是一个阻塞方法，我们调用submit（）执行一个任务的时候，会执行Runnable中的
run（）方法，当run（）方法没有执行完的时候，这个工人就会歇着了，直到run（）方法执行结束后，工人就会立即将结果取回并
且交给我们。我们看到返回的result=null。那既然返回null的话还有什么意义呢？？别着急，那就要用到Callable接口了
Callable登场
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;
}我们看到Callable接口和Runnable接口很像，也是只有一个方法，不过这个call（）方法是有返回值的，这个返回值是一个泛型，也
就是说我们可以根据我们的需求来指定我们要返回的result的类型
public class CallableDemo {
public static void main(String[] args) throws Exception{
ExecutorService es = Executors.newSingleThreadExecutor();
Future<Number> future = es.submit(new CountCallable());
System.out.println("任务开始于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
Number number = future.get();
System.out.println("任务结束于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
if(future.isDone()){
System.out.println("任务执行完毕 result="+number.num);
es.shutdown();
}
}
public static class CountCallable implements Callable<Number>{
@Override
public Number call() throws Exception {
Number number = new Number();
TimeUnit.SECONDS.sleep(2);
number.setNum(10);
return number;
}
}
static class Number{
private int num;
private int getNum(){
return num;
}
private void setNum(int num){
this.num = num;
}
}
} 我们创建我们的任务（Callable）的时候，传入了一个Number类的泛型，那么在call（）方法中就会返回这个Number类型的对象，最后在Future的get（）方法中就会返回我们的Number类型的结果。
FutureTask
说完了Future和Callable，我们再来说最后一个FutureTask，Future是一个接口，他的唯一实现类就是FutureTask，其实FutureTask
的一个很好地特点是他有一个回调函数done（）方法，当一个任务执行结束后，会回调这个done（）方法，我们可以在done（）方
法中调用FutureTask的get（）方法来获得计算的结果。为什么我们要在done（）方法中去调用get（）方法呢？ 这是有原因的，我
在Android开发中，如果我在主线程去调用futureTask.get()方法时，会阻塞我的UI线程，如果在done（）方法里调用get（），则不会
阻塞我们的UI线程。
Runnable接口又实现了Runnable和Future接口，所以说FutureTask可以交给Executor执行，也可以由调用线程直接执行
FutureTask.run（）方法。FutureTask的run（）方法中又会调用Callable的call（）方法
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 {
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);
}
}我们可以看到run方法中其实是先执行了Callable类型的call()方法，然后再调用set()方法将call()方法的返回值赋值给一个全局变
量，在set()方法中将call()方法的返回值传到全局变量，这样通过get方法得到的对象就是call()方法的返回对象，最后当run方法执行完后会调用filishComplete()方法，finishComplete()方法中又会调用抽象方法done()，所以一个FutureTask实际上执行的是一个Callable
类型实例的call（）方法，call()方法才是我们的最终任务，我们写一个例子来演示一下FutureTask
public class MainActivity extends AppCompatActivity {
FutureTask<Number> futureTask;
CountCallable countCallable;
ExecutorService es;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
countCallable = new CountCallable();
futureTask = new FutureTask<Number>(countCallable){
@Override
protected void done() {
try {
Number number = futureTask.get();
Log.i("zhangqi", "任务结束于" + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(new Date()) + " result=" + number.getNum());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
} catch (CancellationException e) {
Log.i("zhangqi", "任务被取消于" + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(new Date()));
}
}
};
es = Executors.newFixedThreadPool(2);
es.execute(futureTask);
Log.i("zhangqi", "任务被开始于" + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(new Date()));
}
public void cancel(View view) {
futureTask.cancel(true);
}
public static class CountCallable implements Callable<Number> {
@Override
public Number call() throws Exception {
Number number = new Number();
Log.i("zhangqi","运行在"+Thread.currentThread().getName());
Thread.sleep(5000);
number.setNum(10);
return number;
}
}
static class Number {
private int num;
private int getNum() {
return num;
}
private void setNum(int num) {
this.num = num;
}
}
}<span style="font-size:14px;"></span>
好了讲完了Future，Callable，FutureTask，我们回到AsyncTask的源码，前面说了executeOnexector方法中
会将一个FutureTask实例提交到线程池中执行，而该实例是在构造方法中被实例化，我们来看看构造方法中的代码
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
return postResult(result);
}
};
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);
}
}
};
}FutureTask的run方法中会先调用WorkerRunnable的call()方法，该方法会调用doInBackground(Params...params)方法
得到一个Result对象，再调用postResult(result)，我们来看看这个方法是干嘛的？
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}因为是在子线程中运行，所以通过Message发送给InternalHandler，我们来看看Handler是怎么处理该Message
@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
@Override
public void handleMessage(Message msg) {
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
// There is only one result
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
} //我们看到调用了AsyncTask的finish()方法
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}在该方法中调用了抽象方法onPostExecute(Result result)，通过Handler实现让该方法在主线程中执行，我们回过头看看
FutureTask中的done方法，在run()方法会将Callable的call()的返回值通过set方法进行赋值，这样通过get()方法可以获取到
Result对象，如果当我们执行了cancel（）方法后，FutureTask的get（）方法会抛出CancellationException异常，我们捕捉这个异
常，然后在这里来处理一些后事 =-=！
其实AsyncTask的源码很简单，也就这么点，还有个publishProgress(Progress...values)方法，很简单
扫一扫
821
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
