使用
提供了簡(jiǎn)單使用線程的方式，必須使用AsyncTask子類，然后調(diào)用execute執(zhí)行任務(wù)即可。
AsyncTask<Params, Progress, Result> {
//在任務(wù)執(zhí)行前調(diào)用，在UI線程中運(yùn)行
protected void onPreExecute() {
}
//抽象方法，在工作線程中執(zhí)行
protected abstract Result doInBackground(Params... params);
//在UI線程中運(yùn)行，在任務(wù)執(zhí)行完成后，調(diào)用，并返回結(jié)果
protected void onPostExecute(Result result) {
}
//在UI線程中運(yùn)行，每次調(diào)用返回任務(wù)進(jìn)度
protected void onProgressUpdate(Progress... values) {
}
//用于提交任務(wù)進(jìn)度，可以在doInBackground中調(diào)用
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
}
源碼分析
主要采用 線程池 + handler 的機(jī)制， 看一下源碼分析
public abstract class AsyncTask<Params, Progress, Result> {
private static final String LOG_TAG = "AsyncTask";
//如果看過(guò)java 線程池實(shí)現(xiàn)的與源碼，看到地下這幾個(gè)參數(shù)，應(yīng)該會(huì)很熟悉，這就是線程池子的基本參數(shù)
//核心保留的線程數(shù)量就一個(gè)
private static final int CORE_POOL_SIZE = 1;
//運(yùn)行中最大的線程數(shù)量
private static final int MAXIMUM_POOL_SIZE = 20;
//？？？
private static final int BACKUP_POOL_SIZE = 5;
//線程空閑之后的存活時(shí)間
private static final int KEEP_ALIVE_SECONDS = 3;
//這個(gè)工廠方法就是用來(lái)創(chuàng)建線程的
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
//不要小看這個(gè)原子性的操作，實(shí)際上包含很多并發(fā)的知識(shí)點(diǎn)
private final AtomicInteger mCount = new AtomicInteger(1);
//創(chuàng)建一個(gè)線程
public Thread newThread(Runnable r) {
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
}
};
//執(zhí)行被拒絕的時(shí)候，使用的線程池
private static ThreadPoolExecutor sBackupExecutor;
//這是一個(gè)任務(wù)隊(duì)列，存儲(chǔ)一些，待執(zhí)行的任務(wù)
private static LinkedBlockingQueue<Runnable> sBackupExecutorQueue;
//這是當(dāng)任務(wù)不能被執(zhí)行時(shí)，調(diào)用的處理方法
private static final RejectedExecutionHandler sRunOnSerialPolicy =
new RejectedExecutionHandler() {
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
android.util.Log.w(LOG_TAG, "Exceeded ThreadPoolExecutor pool size");
// As a last ditch fallback, run it on an executor with an unbounded queue.
// Create this executor lazily, hopefully almost never.
synchronized (this) {
if (sBackupExecutor == null) {
//創(chuàng)建一個(gè)任務(wù)隊(duì)列
sBackupExecutorQueue = new LinkedBlockingQueue<Runnable>();
//創(chuàng)建一個(gè)線程池，用于處理被拒絕的任務(wù)
sBackupExecutor = new ThreadPoolExecutor(
BACKUP_POOL_SIZE, BACKUP_POOL_SIZE, KEEP_ALIVE_SECONDS,
TimeUnit.SECONDS, sBackupExecutorQueue, sThreadFactory);
//核心線程不超時(shí)， 會(huì)一直運(yùn)行，不會(huì)終止，即使沒(méi)有任務(wù)
sBackupExecutor.allowCoreThreadTimeOut(true);
}
}
//執(zhí)行任務(wù)
sBackupExecutor.execute(r);
}
};
//執(zhí)行任務(wù)的（并行）線程池
public static final Executor THREAD_POOL_EXECUTOR;
static {
//創(chuàng)建線程池
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(), sThreadFactory);
//設(shè)置一下，任務(wù)被拒絕的時(shí)候，調(diào)用的方法，就是我們上面的sRunOnSerialPolicy 這個(gè)東西
threadPoolExecutor.setRejectedExecutionHandler(sRunOnSerialPolicy);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
//串行執(zhí)行的線程池
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
//來(lái)分析一下，串行線程池的實(shí)現(xiàn)
private static class SerialExecutor implements Executor {
//一個(gè)簡(jiǎn)單的任務(wù)隊(duì)列
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
//當(dāng)前活躍的任務(wù)
Runnable mActive;
public synchronized void execute(final Runnable r) {
//在隊(duì)列尾部添加任務(wù)
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
//運(yùn)行后，執(zhí)行下一條
scheduleNext();
}
}
});
//當(dāng)前如果沒(méi)有活躍的任務(wù)，觸發(fā)一下任務(wù)
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
//從隊(duì)列中獲取一個(gè)任務(wù)
if ((mActive = mTasks.poll()) != null) {
//從這里也能看出來(lái)實(shí)際上還是借用并行的線程池去運(yùn)行
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
//這兩個(gè)應(yīng)該是消息post出去的code，用來(lái)標(biāo)記的
private static final int MESSAGE_POST_RESULT = 0x1;
private static final int MESSAGE_POST_PROGRESS = 0x2;
//默認(rèn)使用的線程池是串行的
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
//這個(gè)是用于處理從子線程中拋出的數(shù)據(jù)
private static InternalHandler sHandler;
//很明了先直接繼承了Handler類
private static class InternalHandler extends Handler {
public InternalHandler(Looper looper) {
super(looper);
}
@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
@Override
public void handleMessage(Message msg) {
//獲取拋出的數(shù)據(jù)，到這里就是UI主線程了
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
//開始分類處理不同的數(shù)據(jù)， 任務(wù)結(jié)果 或者是 任務(wù)進(jìn)度
switch (msg.what) {
case MESSAGE_POST_RESULT:
//調(diào)用AsyncTask的finihs接口表示任務(wù)結(jié)束了
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
//這里是進(jìn)度的回調(diào)
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
//看一下拋到主線程的數(shù)據(jù)結(jié)構(gòu)
@SuppressWarnings({"RawUseOfParameterizedType"})
private static class AsyncTaskResult<Data> {
//包含兩個(gè)成員變量，一個(gè)是任務(wù)實(shí)例的引用， 一個(gè)是拋出的數(shù)據(jù)
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
//枚舉變量，標(biāo)識(shí)任務(wù)的狀態(tài)
public enum Status {
/**
* 指示任務(wù)還沒(méi)執(zhí)行
*/
PENDING,
/**
* 指示任務(wù)開始運(yùn)行
*/
RUNNING,
/**
* 指示任務(wù)執(zhí)行完成
*/
FINISHED,
}
//看一下構(gòu)造函數(shù)
public AsyncTask(@Nullable Looper callbackLooper) {
//從這里可以看到，實(shí)際上如果沒(méi)有指定特定線程的Loop， 使用的是主線程的Loop
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Result result = null;
try {
//設(shè)置進(jìn)程優(yōu)先級(jí)，沒(méi)看懂， 但是不影響接下來(lái)的閱讀
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//執(zhí)行一下，重載的任務(wù)代碼
result = doInBackground(mParams);
//這個(gè)也是看不明白，看資料這個(gè)代碼有可能堵塞線程
Binder.flushPendingCommands();
} catch (Throwable tr) {
mCancelled.set(true);
throw tr;
} finally {
//將結(jié)果拋出
postResult(result);
}
return result;
}
};
//創(chuàng)建一個(gè)Future處理一下相應(yīng)的錯(cuò)誤
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);
}
}
};
}
//觸發(fā)任務(wù)
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
//調(diào)用下面的方法executeOnExecutor
return executeOnExecutor(sDefaultExecutor, params);
}
//這里算是比較核心的代碼了，
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;
//看一下這里，使用默認(rèn)的串行線程池去執(zhí)行任務(wù)
exec.execute(mFuture);
return this;
}
}
總結(jié)
高并發(fā)的時(shí)候，不適合用，畢竟是串行執(zhí)行的。串行的設(shè)計(jì)可以借用一下。
