AsyncTask学习记录

1. AsyncTask静态变量
    1.1 线程池Thread_pool_executor及其参数
        CPU_COUNT = Runtime.getRuntime().availableProcessors();
        CORE_POOL_SIZE = CPU_COUNT + 1;
        maximum_pool_size = cpu_count * 2 + 1;
        keep_alive = 1;
        ThreadFactory sThreadFactory(AtomicInteger计数);
        BlockingQueue<Runnable> sPoolWorkQueue;
        Executor Thread_pool_executor = new ThreadPoolExecutor(core_pool_size, maximum_pool_size, keep_alive, TimeUtils.Seconds, sPoolWorkQueue, sThreadFactory);
    1.2 顺序执行线程的SERIAL_EXECUTOR(默认执行器volatile sDefaultExecutor)
        class SerialExecutor implements Executor {
            ArrayDeque<Runnable> mTasks;
            Runnable mActive;
            synchronized void execute(Runnnable r);
            synchronized void scheduleNext();
        }
    1.3 Message和Handler
        message_post_result
        message_post_progress
        sHandler
2. AsyncTask普通变量
    1. Callable
        WorkRunnable<Params, Result> mWorker;
        FutureTask<Result> mFuture(mWorker);
    2. 状态
        volatile mStates;
        AtomicBoolean mCancelled;
        AtomicBoolean mTaskInvoked;
3. 流程
    mAsyncTask.execute(Params...)
    ->executeOnExecutor(sDefaultExecutor, params)
        1. 判断状态mStates是否为pending
        2. 设置状态mStates为Running
        3. onPreExecute()     // 重载实现
        4. mWorker.mParams = params;
            exec.execute(mFuture);
            4.1 SerialExecutor
            synchronized void execute(mFuture) {
                mTasks.offer(new Runnable{mFuture.run(); scheduleNext();}); // new 一个Runnable添加在数组队列mTask中，Runnable中运行mFuture和scheduleNext;
                (mActive == null) = true, scheduleNext();    // mActive当前正在执行Runnable=null，执行next.
            }
            synchronized void scheduleNext() {
                if ((mActive=mTask.poll()) !=null)   //刚在execute中offer,所以不为null
                    Thread_pool_executor.execute(mActive);   //在线程池中执行mActive(mActive中执行mFuture, 最终执行了mFuture)
            }
            4.2 mFuture(在线程池中执行)
            mFuture中的Callable参数为mWorker,所以执行mWorker.call()
            mWorker::Result call() {
                mTaskInvoked.set(true);        // 设置状态为已调用
                Process.setThreadPriority(Process.thread_priority_background);   // 设置任务为后台任务

                result = doInBackground(mParams);    // 重载实现
                Binder.flushPendingCommand();    
                return postResult(result);    // 发送post_result消息给handler，返回result本身
                    4.2.1
                    Result postResult(Result result) {
                        Message msg = sHandler.obtionMsg(Message_post_result, new AsyncTaskResult(this, result));
                        msg.sendToTarget();
                        return result;
                    }
                    4.2.2
                    sHandler收到post_result消息，
                        msg.obj.mTask.finish(msg.obj.mData[0]);  // msg.obj为this，即本AsyncTask的finish方法
                    void finish(Result result) {
                        if (isCancelled()) {onCancelled(result);}   // 重载实现
                        else {onPostExecute(result);}    // 重载实现
                        mStates = FINISH;    // 置状态为结束
                    }
            }
            mFuture::void done() {
                postResultIfNotInvoked(get());   // get()拿到mWorker的call的result
                    void postResultIfNotInvoked(Result result) {
                        if (!mTaskInvoked.get())    //  在call中置为true
                            postResult(result);
                    }
            }
        5. return this;
4. Others
    4.1 阻塞问题
    api11后AsyncTask默认是串行执行任务，即顺序执行。所以在AsyncTask中只能进行短时的操作，防止阻塞线程池。
    调用executeOnExecutor(AsyncTask.Thread_pool_executor)来立即执行任务，但限于线程池的最大并发数，也有可能导致阻塞。
    4.2 cancel问题
    cancel方法调用的是Thread.interrupt(),只是将中止状态置为true，并不能真正的cancel任务的doInBackground方法。
    只能是自己在doInBackground中进行中断处理。
    4.3 多任务管理问题
    AsyncTask只能执行一次execute，所以有多个后台任务时，只能设置多个AsyncTask，在退出的时候需要对多个AsyncTask做处理

    来避免UI问题及内存泄漏，问题(如Thread异常等)排查困难。

参考：

http://www.jianshu.com/p/d83fd0e8a062

http://www.jianshu.com/p/de424983ba83