AsyncTask源码模拟

这章将研究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 sPoolWorkQueue =
            new LinkedBlockingQueue(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 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 implements Callable{
    P[] param;
}

其中泛型R代表结果参数,P代表传入的参数
初始化如下:

private final AtomicBoolean mTaskInvoked = new AtomicBoolean(false);
private final AtomicBoolean mCancelled = new AtomicBoolean(false);

WorkParam worker = new WorkParam() {
    @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(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(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 {
    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 execute(Params... params){
    return executeOnExecutor(new ThreadExector(), params);
}

private final AsyncTask 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(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*类型控制结果

你可能感兴趣的:(AsyncTask源码模拟)