AsyncTask詳解
[導(dǎo)讀]? ? ? ? 作為Android中最常用跨線程手段之一，AsyncTask經(jīng)常出現(xiàn)在代碼中。我也經(jīng)常使用AsyncTask，有一次遇到一個奇怪的情況：AsyncTask.execute()函數(shù)調(diào)用后
? ? ? ? 作為Android中最常用跨線程手段之一，AsyncTask經(jīng)常出現(xiàn)在代碼中。我也經(jīng)常使用AsyncTask，有一次遇到一個奇怪的情況：AsyncTask.execute()函數(shù)調(diào)用后，AsyncTask卻未立即執(zhí)行，而是過了一段時間以后，才開始執(zhí)行，當時覺得很奇怪，一番Google后，得知是線程池的原因。事后也一直擱著，直到今天工作有點空，花了點時間看看AsyncTask的實現(xiàn)。
AsyncTask的線程池??????? AsyncTask提供了兩個線程池,用以執(zhí)行后臺任務(wù)：
??????? 當然,開發(fā)者也可以通過自定義線程池來執(zhí)行后臺任務(wù)：
??????? THREAD_POOL_EXECUTOR的定義為：
/**
* An {@link Executor} that can be used to execute tasks in parallel.
*/
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory); private static final int CORE_POOL_SIZE = 5;
private static final int MAXIMUM_POOL_SIZE = 128;
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) {
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());//創(chuàng)建一個擁有特定名字的線程
}
};
private static final BlockingQueue sPoolWorkQueue =
new LinkedBlockingQueue(10); ?????? 從當前的參數(shù)我們可以看到，THREAD_POOL_EXECUTOR最多同時擁有128個線程執(zhí)行任務(wù)，通常情況下（sPoolWorkQueue有任務(wù)，且未滿），THREAD_POOL_EXECUTOR會擁有5條線程同時處理任務(wù)。
??????? 默認情況下，AsyncTask會在SERIAL_EXECUTOR中執(zhí)行后臺任務(wù)(其實，這個說法不太準確，稍后解釋):
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR; /**
* An {@link Executor} that executes tasks one at a time in serial
* order. This serialization is global to a particular process.
*/
public static final Executor SERIAL_EXECUTOR = new SerialExecutor(); private static class SerialExecutor implements Executor {
final ArrayDeque mTasks = new ArrayDeque();
Runnable mActive;
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
} ?????? 所以，實際上所有的后臺任務(wù)都是在THREAD_POOL_EXECUTOR中執(zhí)行的，而
AsyncTask.execute()AsyncTask.executorOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR)AsyncTask的實現(xiàn)
??????? AsyncTask的實現(xiàn)，需要依賴于兩個成員：
private final WorkerRunnable mWorker;
private final FutureTask mFuture;
??????? WorkerRunnable的定義為：
private static abstract class WorkerRunnable implements Callable {
Params[] mParams;
} public interface Callable {
/**
* 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;
} /**
* Creates a new asynchronous task. This constructor must be invoked on the UI thread.
*/
public AsyncTask() {
mWorker = new WorkerRunnable() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
return postResult(doInBackground(mParams));
}
};
mFuture = new FutureTask(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 occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
} ???????? call函數(shù)的重載挺簡單，主要就是調(diào)用doInBackground函數(shù)，執(zhí)行后臺任務(wù)。
??????? FutureTask的實現(xiàn)比WorkerRunnable復(fù)雜，但是，如果抓住核心去分析也很簡單。
??????? 首先， FutureTask實現(xiàn)了RunnableFuture接口：
public class FutureTask implements RunnableFuture { public interface RunnableFuture extends Runnable, Future {
/**
* Sets this Future to the result of its computation
* unless it has been cancelled.
*/
void run();
} public void run() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable 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);
}
} public FutureTask(Callable callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
} /**
* Creates a new asynchronous task. This constructor must be invoked on the UI thread.
*/
public AsyncTask() {
mWorker = new WorkerRunnable() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
return postResult(doInBackground(mParams));
}
};
mFuture = new FutureTask(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 occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
} AsyncTask.execute函數(shù)的執(zhí)行過程 ?????? 1. AsyncTask.execute
public final AsyncTask execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
} public final AsyncTask 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();//調(diào)用onPreExecute
mWorker.mParams = params;//保存參數(shù)
exec.execute(mFuture);//執(zhí)行task
return this;
} void execute(Runnable runnable）{
new Thread(runnable).start();
} public void run() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable 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);
}
} ???????? 4. WorkerRunnable.call()
mWorker = new WorkerRunnable() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
return postResult(doInBackground(mParams));
}
}; private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult(this, result));
message.sendToTarget();
return result;
} ??????? 6. sHandler.handleMessage
private static class InternalHandler extends Handler {
@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;
}
}
} private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}總結(jié)
?????? 從本質(zhì)上來講，AsyncTask即為Execute和Handler的組合。AsyncTask利用Executor在后臺線程中執(zhí)行doInBackgroud函數(shù)，并利用handler執(zhí)行onPostExecute函數(shù)。
?????? 而AsyncTask的行為則由executeOnExecutor函數(shù)中參數(shù)exec決定。AsyncTask提供的SERIAL_EXECUTOR限定任務(wù)逐個執(zhí)行，而THREAD_POOL_EXECUTOR支持最多128個任務(wù)并行執(zhí)行，但是當待處理任務(wù)過多時，會拋出RejectedExecutionException。
下載文檔
