这章将研究AsyncTask的实现原理，并自己尝试编写一个相同的异步操作类
这章你将学习到的关键词：
AsyncTask
线程相关:
ThreadPoolExector,Exector, ArrayDeque双向队列
任务操作相关:
FutureTask<?>(Callable<?> r) [?表示泛型]
其他类：
AtomicBoolean或者Atomic* [*表示基本数据类型, Atomic表示自增长]
下面我们便开始着手编写我们的异步线程并结合AsyncTask源码
需求：
1.我们要写一个异步线程，这个线程需要写在线程池里面
2.我们的线程需要传入自定义类型，回调能够有自定义类型参数回调
3.我们的线程必须要能有相应的回调，以及能够取消
1.编写异步线程
你需要一个线程池TheadPoolExector, 你需要一个Exector来实现runnable
一般你可能会这样写：
ExecutorService service = Executors.newFixedThreadPool(3);
这样就创建了Exector与TheadPoolExector, 但是阿里的编码规范里面推荐手动创建线程池，那么我们可以自定义实现Executor接口来创建我们的线程池TheadPoolExector，这里直接上代码：
/**
* Created by Qzhu on 2018/5/18.
*/
public class ThreadExector implements Executor{
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
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;
private static final int KEEP_ALIVE_SECONDS = 30;
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger atomicInteger = new AtomicInteger(1);
@Override
public Thread newThread(Runnable r) {
return new Thread("ThreadExector #" + atomicInteger.getAndIncrement());
}
};
static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
sPoolWorkQueue, sThreadFactory);
threadPoolExecutor.allowCoreThreadTimeOut(true);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
/**
* An {@link Executor} that can be used to execute tasks in parallel.
*/
public static final Executor THREAD_POOL_EXECUTOR;
final ArrayDeque<Runnable> queue = new ArrayDeque<>();
Runnable point = null;
@Override
public void execute(final Runnable command) {
queue.offer(new Runnable() {
@Override
public void run() {
try {
command.run();
}finally {
scheduleNext();
}
}
});
if(point == null) {
scheduleNext();
}
}
private void scheduleNext() {
if((point = queue.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(point);
}
}
}
类解析：
我们可以看到这是一个自定义的Exector实现类，里面初始化了ThreadPoolExector，定制了参数（初始化请自行百度~），实现的execute里面的runnable使用了双向队列ArrayDeque包装，这样可以不停取出里面的runnable并放入ThreadPoolExector执行，只要execute执行多少次都是排入队列并等待弹出执行（等下我们将分析怎样限制其之执行一次[其实只要加个状态就行啦]）
以上我们便准备好了线程执行者，以及可以先这样用了
new ThreadExector().execute(Runnable r);
下面我们需要对参数Runnaber r进行包装使用的是FutureTask<?>(Callable<?> r)，先来大概了解以下FutureTask<?>(Callable<?> r)这个类对Runnable的包装吧，FutureTask实现了Runnable将执行Run方法，然后里面执行Callable的call方法，或者其他情况将执行自身的done方法，比如取消或者异常等，而?泛型代表返回参数，这就符合条件2的自定义结果参数，下面缺少自定义入参，这一点只要添加一个泛型就行了
我们先实现FutureTask<?>(Callable<?> r)里面的Callable<?>：
public abstract class WorkParam<R,P> implements Callable<R>{
P[] param;
}
其中泛型R代表结果参数，P代表传入的参数
初始化如下：
private final AtomicBoolean mTaskInvoked = new AtomicBoolean(false);
private final AtomicBoolean mCancelled = new AtomicBoolean(false);
WorkParam worker = new WorkParam<Result,Params>() {
@Override
public Result call() throws Exception {
Result r = null;
mTaskInvoked.set(true);
android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND);
try {
r = doInBackgroud(param);
}catch (Exception e) {
mCancelled.set(true);
r = null;
}finally {
postResult(r);
}
Binder.flushPendingCommands();
return r;
}
};
这段代码编写参考AsyncTask,实现call的方法，在里面回调doInBackgroud执行具体异步操作，同名AsyncTask接口方法，而onPostExecute也是AsyncTask接口方法，这里先调用doInBackgroud放到后台让Exector工作，然后执行postResult（见下面具体实现），最后就是回调onPostExecute接口方法
以上是Callable<?> r的包装，还有一个FutureTask<?>如下：
futureTask = new FutureTask<Result>(worker){
@Override
protected void done() {
super.done();
try {
postIfNotInvoke(get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}catch (CancellationException e) {
postIfNotInvoke(null);
}
}
};
private void postIfNotInvoke(Result r){
if(!mTaskInvoked.get()) {
postResult(r);
}
}
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = innerHandller.obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
//定义一个InnerHandler来处理线程切换回调
private static final int MESSAGE_POST_RESULT = 0x1;
private static final int MESSAGE_POST_PROGRESS = 0x2;
private Handler innerHandller = new Handler(Looper.getMainLooper()){
@Override
public void handleMessage(Message msg) {
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
result.mTask.onPostExecute(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
default:
break;
}
}
};
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
这个方法表示如果操作被其他行为中断，比如取消，执行postIfNotInvoke方法，而这个方法将判断线程是否执行过Callable<?>的call方法，里面的mTaskInvoked是一个标志，用于区分是否被执行过，如果执行过将回调postExecute，使用handler来切换到主线程回调，这样我们就实现了doInBackgroud与onPostExecute 回调
至于如何实现onpreExecute其实只要在execute方法里面调用就行的，如下：
public AsyncTask<Params, Process, Result> execute(Params... params){
return executeOnExecutor(new ThreadExector(), params);
}
private final AsyncTask<Params, Process, Result> executeOnExecutor(Executor exec,Params... params){
onPreExecute();
worker.param = params;
exec.execute(futureTask);
return this;
}
关于实现进度更新，其实上面自定义的InnerHandler里面有切换到主线程回调跟新，只需要定义公开方法就行，如下：
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
protected void onProgressUpdate(Progress... values) {
}
以上过程便是AsyncTask的实现流程，首先在构造函数里面初始化FutureTask<?>(Callable<?> r),然后执行execute的时候将准备好的线程池Exector来执行该FutureTask，回调对应实现体内部，线程的取消可以由FutureTask控制，使用几个AtomicBoolean作为标志位来控制结果的回调，状态是否取消等等，在Callable执行call方法里面可以使用InnerHandler来切换到主线程，这便是AsyncTask源码的实现方式
总结以下：
1.[重要]自定义Exector线程池（ArrayDeque双向无限扩充队列）
2.[重要]Runnable包装类FutureTask<?>(Callable<?> r)的使用，泛型的传递
3.线程切换回调方法InnerHandler的定义与参数的定义
4.Atomic*类型控制结果
