package android.os;
import android.annotation.MainThread;
import android.annotation.Nullable;
import android.annotation.WorkerThread;
import java.util.ArrayDeque;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.FutureTask;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 作者：å¶åº”是å¶
* 时间：2018/6/24 15:01
* æ述：https://github.com/leavesC/Java_Android_Learn
* https://www.jianshu.com/u/9df45b87cfdf
*/
public abstract class AsyncTask {
private static final String LOG_TAG = "AsyncTask";
//CPU æ ¸æ•°é‡
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
//çº¿ç¨‹æ± ä¸çš„æ ¸å¿ƒçº¿ç¨‹æ•°
//至少有2个，最多4个，线程数至少è¦æ¯” CPU æ ¸æ•°é‡å°‘1个，以é¿å… CPU 与åŽå°å·¥ä½œé¥±å’Œ
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
//çº¿ç¨‹æ± å®¹çº³çš„æœ€å¤§çº¿ç¨‹æ•°é‡
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
//线程在闲置时的å˜æ´»æ—¶é—´ï¼ˆ30秒），超出这个时间将被回收
private static final int KEEP_ALIVE_SECONDS = 30;
//线程队列
//当 LinkedBlockingDeque 已满时，新增的任务会直接创建新线程æ¥æ‰§è¡Œï¼Œå½“创建的线程数é‡è¶…è¿‡æœ€å¤§çº¿ç¨‹æ•°é‡ KEEP_ALIVE_SECONDS 时会抛出异常
private static final BlockingQueue sPoolWorkQueue = new LinkedBlockingQueue(128);
//线程工厂，æ供创建新线程的功能，通过线程工厂å¯ä»¥å¯¹çº¿ç¨‹çš„一些属性进行定制
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());
}
};
//çº¿ç¨‹æ± å¯¹è±¡
public static final Executor THREAD_POOL_EXECUTOR;
static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
sPoolWorkQueue, sThreadFactory);
//åŒ…æ‹¬æ ¸å¿ƒçº¿ç¨‹åœ¨å†…çš„æ‰€æœ‰çº¿ç¨‹åœ¨é—²ç½®æ—¶é—´è¶…å‡º KEEP_ALIVE_SECONDS åŽéƒ½å°†å…¶å›žæ”¶
threadPoolExecutor.allowCoreThreadTimeOut(true);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
//串行任务执行器，å³æäº¤ç»™çº¿ç¨‹æ± çš„ä»»åŠ¡æ˜¯æŒ‰ç…§é¡ºåºï¼Œç‰ä¸Šä¸€ä¸ªæ‰§è¡Œç»“æŸå†æ‰§è¡Œä¸‹ä¸€ä¸ªçš„
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
//用于当任务完æˆæ—¶ä¼ 递执行结果
private static final int MESSAGE_POST_RESULT = 0x1;
//用于更新任务的进度值
private static final int MESSAGE_POST_PROGRESS = 0x2;
//å½“å‰ Task 使用的任务执行器
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
//按照æ£å¸¸æƒ…况æ¥è¯´ï¼Œåœ¨åˆå§‹åŒ– AsyncTask æ—¶æˆ‘ä»¬ä½¿ç”¨çš„éƒ½æ˜¯å…¶æ— å‚æž„é€ å‡½æ•°
//å› æ¤ InternalHandler 绑定的 Looper 对象å³æ˜¯ä¸Žä¸»çº¿ç¨‹å…³è”çš„ Looper 对象
//所以 InternalHandler å¯ä»¥ç”¨æ¥åœ¨ UI 线程回调æŸäº›æŠ½è±¡æ–¹æ³•ï¼Œä¾‹å¦‚ onProgressUpdate() 方法
private static InternalHandler sHandler;
//ç‰äºŽ sHandler
private final Handler mHandler;
private final WorkerRunnable mWorker;
private final FutureTask mFuture;
//å½“å‰ Task 的状æ€
private volatile Status mStatus = Status.PENDING;
//ç”¨äºŽæ ‡è®°å½“å‰åŽå°ä»»åŠ¡æ˜¯å¦å·²è¢«å–消
private final AtomicBoolean mCancelled = new AtomicBoolean();
//ç”¨äºŽæ ‡è®°å½“å‰åŽå°ä»»åŠ¡æ˜¯å¦å·²è¢«æ‰§è¡Œ
private final AtomicBoolean mTaskInvoked = new AtomicBoolean();
//串行任务执行器，å³æäº¤ç»™çº¿ç¨‹æ± çš„ä»»åŠ¡æ˜¯æŒ‰ç…§é¡ºåºä¸€ä¸ªæŽ¥ä¸€ä¸ªè¢«æ‰§è¡Œçš„
private static class SerialExecutor implements Executor {
//任务队列
final ArrayDeque mTasks = new ArrayDeque();
//当å‰åœ¨æ‰§è¡Œçš„任务
Runnable mActive;
public synchronized void execute(final Runnable r) {
//å‘任务队列尾端æ’入任务
//在外部任务外部包装多一层 Runnable
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);
}
}
}
private static class InternalHandler extends Handler {
public InternalHandler(Looper looper) {
super(looper);
}
@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
@Override
public void handleMessage(Message msg) {
AsyncTaskResult> result = (AsyncTaskResult>) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
//处ç†åŽå°ä»»åŠ¡çš„执行结果
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
//æ›´æ–°åŽå°ä»»åŠ¡çš„进度
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
private static abstract class WorkerRunnable implements Callable {
Params[] mParams;
}
@SuppressWarnings({"RawUseOfParameterizedType"})
private static class AsyncTaskResult {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
//ç”¨äºŽæ ‡è®° Task 的当å‰çŠ¶æ€
public enum Status {
//Task 还未è¿è¡Œ
PENDING,
//Task æ£åœ¨è¿è¡Œ
RUNNING,
//Task å·²ç»ç»“æŸ
FINISHED,
}
//获å–与主线程关è”çš„ Looper 对象，以æ¤ä¸ºå‚数构建一个 Handler 对象
//所以在 Task çš„è¿è¡Œè¿‡ç¨‹ä¸ï¼Œèƒ½å¤Ÿé€šè¿‡æ¤ Handler 在 UI 线程执行æ“作
private static Handler getMainHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler(Looper.getMainLooper());
}
return sHandler;
}
}
private Handler getHandler() {
return mHandler;
}
//éšè—函数
public static void setDefaultExecutor(Executor exec) {
sDefaultExecutor = exec;
}
//创建一个新的异æ¥ä»»åŠ¡ï¼Œå¿…须在UI线程上调用æ¤æž„é€ å‡½æ•°
public AsyncTask() {
this((Looper) null);
}
/**
* éšè—çš„æž„é€ å‡½æ•°
* 创建一个新的异æ¥ä»»åŠ¡ï¼Œå¿…须在UI线程上调用æ¤æž„é€ å‡½æ•°
*
* @hide
*/
public AsyncTask(@Nullable Handler handler) {
this(handler != null ? handler.getLooper() : null);
}
/**
* éšè—çš„æž„é€ å‡½æ•°
* 创建一个新的异æ¥ä»»åŠ¡ï¼Œå¿…须在UI线程上调用æ¤æž„é€ å‡½æ•°
* @hide
*/
public AsyncTask(@Nullable Looper callbackLooper) {
//如果 callbackLooper 为 null 或者是ç‰äºŽä¸»çº¿ç¨‹ Looper ，则以主线程 Looper 对象为å‚数构建一个与主线程关è”çš„ Handler 对象
//å¦åˆ™å°±ä»¥ä¼ 入的 Looper 对象为å‚æ•°æ¥æž„建与å线程关è”çš„ Handler
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper() ? getMainHandler() : new Handler(callbackLooper);
mWorker = new WorkerRunnable() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Result result = null;
try {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
result = doInBackground(mParams);
Binder.flushPendingCommands();
} catch (Throwable tr) {
mCancelled.set(true);
throw tr;
} finally {
postResult(result);
}
return result;
}
};
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 occurred while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
}
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {
postResult(result);
}
}
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT, new AsyncTaskResult(this, result));
message.sendToTarget();
return result;
}
//获å–å½“å‰ Task 的状æ€
public final Status getStatus() {
return mStatus;
}
//在å线程ä¸è¢«è°ƒç”¨ï¼Œç”¨äºŽæ‰§è¡ŒåŽå°ä»»åŠ¡
@WorkerThread
protected abstract Result doInBackground(Params... params);
//在 UI 线程ä¸è¢«è°ƒç”¨ï¼Œåœ¨ doInBackground() 方法之å‰è°ƒç”¨ï¼Œç”¨äºŽåœ¨åŽå°ä»»åŠ¡å¼€å§‹å‰åšä¸€äº›å‡†å¤‡å·¥ä½œ
@MainThread
protected void onPreExecute() {
}
//在 UI 线程ä¸è¢«è°ƒç”¨ï¼Œåœ¨ doInBackground() 方法之åŽè°ƒç”¨ï¼Œç”¨äºŽå¤„ç†åŽå°ä»»åŠ¡çš„执行结果
//å‚æ•° result 是 doInBackground() 方法的返回值
@SuppressWarnings({"UnusedDeclaration"})
@MainThread
protected void onPostExecute(Result result) {
}
//在 UI 线程ä¸è¢«è°ƒç”¨ï¼Œå½“调用了 publishProgress() 方法åŽè¢«è§¦å‘
//用于更新任务进度值
@SuppressWarnings({"UnusedDeclaration"})
@MainThread
protected void onProgressUpdate(Progress... values) {
}
//在 UI 线程ä¸è¢«è°ƒç”¨
//当调用了 cancel(boolean) 方法å–消åŽå°ä»»åŠ¡åŽä¼šè¢«è°ƒç”¨
//在 doInBackground() 方法结æŸæ—¶ä¹Ÿä¼šè¢«è°ƒç”¨
//方法内部默认调用了 onCancelled() 方法
@SuppressWarnings({"UnusedParameters"})
@MainThread
protected void onCancelled(Result result) {
onCancelled();
}
//在 UI 线程ä¸è¢«è°ƒç”¨ï¼Œè¢« onCancelled(Result) 方法调用
@MainThread
protected void onCancelled() {
}
//如果 Task 在完æˆä¹‹å‰è¢«å–消了则返回 true
public final boolean isCancelled() {
return mCancelled.get();
}
//å–消任务
public final boolean cancel(boolean mayInterruptIfRunning) {
mCancelled.set(true);
return mFuture.cancel(mayInterruptIfRunning);
}
/**
* Waits if necessary for the computation to complete, and then
* retrieves its result.
*
* @return The computed result.
* @throws CancellationException If the computation was cancelled.
* @throws ExecutionException If the computation threw an exception.
* @throws InterruptedException If the current thread was interrupted
* while waiting.
*/
public final Result get() throws InterruptedException, ExecutionException {
return mFuture.get();
}
/**
* Waits if necessary for at most the given time for the computation
* to complete, and then retrieves its result.
*
* @param timeout Time to wait before cancelling the operation.
* @param unit The time unit for the timeout.
* @return The computed result.
* @throws CancellationException If the computation was cancelled.
* @throws ExecutionException If the computation threw an exception.
* @throws InterruptedException If the current thread was interrupted
* while waiting.
* @throws TimeoutException If the wait timed out.
*/
public final Result get(long timeout, TimeUnit unit) throws InterruptedException,
ExecutionException, TimeoutException {
return mFuture.get(timeout, unit);
}
//以默认的串行任务执行器 sDefaultExecutor æ¥æ‰§è¡ŒåŽå°ä»»åŠ¡
@MainThread
public final AsyncTask execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
//以指定的任务执行器 Executor æ¥æ‰§è¡ŒåŽå°ä»»åŠ¡
@MainThread
public final AsyncTask executeOnExecutor(Executor exec, Params... params) {
//Task åªèƒ½è¢«æ‰§è¡Œä¸€æ¬¡ï¼Œå¦‚æžœ mStatus != Status.PENDING ，说明 Task 被é‡å¤æ‰§è¡Œï¼Œæ¤æ—¶å°†æŠ›å‡ºå¼‚常
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;
//在 doInBackground() 方法之å‰è¢«è°ƒç”¨ï¼Œç”¨äºŽåšä¸€äº›ç•Œé¢å±‚的准备工作
onPreExecute();
//执行耗时任务
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
//直接执行 Runnable 指å‘的任务，ä¸ä¼šè§¦å‘å„个抽象方法
@MainThread
public static void execute(Runnable runnable) {
sDefaultExecutor.execute(runnable);
}
//è¿è¡ŒäºŽå·¥ä½œçº¿ç¨‹ï¼Œæ¤æ–¹æ³•ç”¨äºŽæ›´æ–°ä»»åŠ¡çš„进度值
//ä¼šè§¦å‘ onProgressUpdate() 被执行
@WorkerThread
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
//将与进度值相关的å‚æ•° Progress 包装到 AsyncTaskResult 对象当ä¸ï¼Œå¹¶ä¼ 递给 Handler 进行处ç†
getHandler().obtainMessage(MESSAGE_POST_PROGRESS, new AsyncTaskResult