你真的了解AsyncTask吗？AsyncTask源码分析

转载请注明出处：http://blog.csdn.net/yianemail/article/details/51611326

1，概述
Android UI是线程不安全的，如果想要在子线程很好的访问ui， 就要借助Android中的异步消息处理机制
http://blog.csdn.net/yianemail/article/details/50233373
通过Thread 执行耗时操作，通常利用Handler 发送消息给ui线程。
这种方式代码相对臃肿，并且不能对多任务执行很好的控制。

为了简化操作，Android 1.5提供了更加轻量级的AsyncTask异步工具类，使创建异步任务变得异常简单。

2，AsyncTask 的使用

看一个最典型的AsyncTask 简单使用场景

package com.listenread.luhuanju.helloword;
import android.os.AsyncTask;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //AsyncTask 开始执行异步任务
        new MyAsyncTask().execute();
    }

    class MyAsyncTask extends AsyncTask<Void, Void, String> {
        @Override
        protected String doInBackground(Void... params) {
            //Commen is request resurce from http and return to onPostExecute
            //模拟数据返回
            return "mStr";
        }

        @Override
        protected void onPostExecute(String s) {
            super.onPostExecute(s);
            //获取数据
        }
    }
}

3，源码解析

既然代码入口

new MyAsyncTask().execute();

我们就从它的构造函数分析，

  /**
     * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
     * 方法注释就说明了必须要在ui thread 进行AsyncTask调用
     */
    public AsyncTask() {
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);

                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                //noinspection unchecked
                Result result = doInBackground(mParams);
                Binder.flushPendingCommands();
                return postResult(result);
            }
        };

        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);
                }
            }
        };

来分析一下构造函数实例化的两个变量
mWorker 以及 mFuture

    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }

可以看到mWorker 是实现了参数是泛型的 Callable接口，看下Callable接口的声明

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

只有一个返回类型为泛型的 Call() 方法。

这里介绍一下Callable 这个接口，在java中，实现多线程的方法除了Runnable之外，还有Callable,Future 以及FutureTask(没错，就是一会要分析的这货)，与Runnable不同的是，这几个类型都只能在线程池当中实现。Callable 与 Runnable 最关键的异点是Callable 可以有返回值。然而Runnable 是拿不到执行的返回值的。
这也就再一次解释了

public interface Callable<V> {
    V call() throws Exception; //返回值泛型v
}

对比Runnable的接口声明

public interface Runnable {
    public void run(); //无返回值
}

再来看一下mFuture 这货，可以看到把mWorker当作参数

public class FutureTask<V> implements RunnableFuture<V> {

可以看到FutureTask 实现了RunnableFuture< V>接口

public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

而RunnableFuture 继承了Runnable 以及Future
终于到了Future了，继续看Future 的声明

public interface Future<V> {
 /**
  * ...忽略方法的注释声明
  */
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

看到这 我们大概明白了AsyncTask的一大优势所在，没错，就是可控。
总结一下FutureTask的作用，FutureTask作为一个可管理的异步任务，使得在线程池中执行的异步任务可以被更精准的控制。

分析完构造函数中 两个实例化的变量，在继续看execute()方法

    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }

execute()继续调用了executeOnExecutor(sDefaultExecutor, params) ，并且传递两个参数sDefaultExecutor以及params

我们看下sDefaultExecutor

    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

   public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

所以我们只需要看下SerialExecutor 的实现即可；

  private static class SerialExecutor implements Executor {
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        Runnable mActive;

        public synchronized void execute(final Runnable r) {
            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);
            }
        }
    }

SerialExecutor就是一个线程池， AsyncTask 的内部类，实现了Executor 接口

public interface Executor {

    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the {@code Executor} implementation.
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

我们看下这句方法的注释就能明白execute()的作用就是在线程池中分配线程执行异步任务。那么execute()方法在AsyncTask 到底执行什么任务呢？没错，就是

 public synchronized void execute(final Runnable r) {
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }

我们发现了 mTasks.offer 这个方法，看下mTasks

final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();

简单说一下ArrayDeque

ArrayDeque是一个双端队列，它具有：

数组双端队列没有容量限制，使他们增长为必要支持使用。

不支持多线程并发访问。

它们要比堆栈Stack和LinkedList快。

看下它的offer（）

   /**
     * Inserts the specified element at the end of this deque.
     * 这句注释的意思就是说添加特定的元素（就是Runnable）到队尾
     * <p>This method is equivalent to {@link #offerLast}.
     *
     * @param e the element to add
     * @return <tt>true</tt> (as specified by {@link Queue#offer})
     * @throws NullPointerException if the specified element is null
     */
    public boolean offer(E e) {
        return offerLast(e);
    }

调用的 offerLast(e)

    public boolean offerLast(E e) {
        addLast(e);
        return true;
    }

继续addLast（e）

    public void addLast(E e) {
        if (e == null)
            throw new NullPointerException("e == null");
        elements[tail] = e;
        if ( (tail = (tail + 1) & (elements.length - 1)) == head)
            doubleCapacity();
    }

 /**
     * Double the capacity of this deque.  Call only when full, i.e.,
     * when head and tail have wrapped around to become equal.
     */
    private void doubleCapacity() {
        // assert head == tail;
        int p = head;
        int n = elements.length;
        int r = n - p; // number of elements to the right of p
        int newCapacity = n << 1;
        if (newCapacity < 0)
            throw new IllegalStateException("Sorry, deque too big");
        Object[] a = new Object[newCapacity];
        System.arraycopy(elements, p, a, 0, r);
        System.arraycopy(elements, 0, a, r, p);
        elements = a;
        head = 0;
        tail = n;
    }

简单分析一下addLast（e） 的作用吧，如果传入参数为空，抛出异常
如果此时队列已满，就执行doubleCapacity（）；而这个方法就是把ArrayDeque扩容的，通过

       ...
        int r = n - p; // number of elements to the right of p
        int newCapacity = n << 1;//二进制，左移
        ...
        Object[] a = new Object[newCapacity];
        System.arraycopy(elements, p, a, 0, r);
        System.arraycopy(elements, 0, a, r, p);
       ...

我们可知，满了就要扩容一倍的

说了这么多，我们重新回顾一下SerialExecutor

private static class SerialExecutor implements Executor {
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        Runnable mActive;

        public synchronized void execute(final Runnable r) {
            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);
            }
        }
    }

分析一下它的执行过程
第一次运行的时候，毫无疑问，局部变量mActive为null，执行scheduleNext（）方法

  protected synchronized void scheduleNext() {
            if ((mActive = mTasks.poll()) != null) {
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }

又看到了 THREAD_POOL_EXECUTOR

    public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

THREAD_POOL_EXECUTOR 也是一个线程池，通过构造函数初始化了
核心线程数，超时时长，所容纳的最大线程数，等一系类配置。在我的sdk版本好像对之前4.x做了优化，并没有固定写死，因为是这样的

  private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    private static final int KEEP_ALIVE = 1;

sDefaultExecutor 线程池内部维护一个任务队列（ArrayDeque）,
execute()方法，将Runnable放入队尾，第一次执行 走scheduleNext()，此时 mTasks.poll() 取出队首任务，不为空则传入THREAD_POOL_EXECUTOR进行执行。

4，执行过程回顾
再来看一下 AsyncTask.execute()的执行过程

 @MainThread
    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();  //熟悉这个onPreExecute（）方法吗？
        mWorker.mParams = params;//外部参数赋值给mWorker局部变量
        //最主要的逻辑就在这个方法了,提交mFuture执行，封装了worker,
        exec.execute(mFuture);
        return this;
    }

mFuture 是需要mWorker 作为参数，而mWorker的执行

  mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                 //提升线程的优先级 
              Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                //noinspection unchecked
                //看到了吗？这里的doInBackground 执行的就是你外部调用的 doInBackground（）的逻辑。
                Result result = doInBackground(mParams);
                Binder.flushPendingCommands();
                return postResult(result);
            }
        };

拿到结果调用postResult(result)

   private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        //getHandler（）实际上就是 super(Looper.getMainLooper());，也就是Main 中的looper
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

AsyncTaskResult就是一个简单的携带参数的对象。
看到Messager 肯定会有Handler，于是找到

  private static class InternalHandler extends Handler {
        public InternalHandler() {
            super(Looper.getMainLooper());
        }

        @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
        @Override
        public void handleMessage(Message msg) {
            AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
            switch (msg.what) {
                case MESSAGE_POST_RESULT:
                    // There is only one result
                    result.mTask.finish(result.mData[0]);
                    break;
                case MESSAGE_POST_PROGRESS:
                    result.mTask.onProgressUpdate(result.mData);
                    break;
            }
        }
    }

result.mTask.finish(result.mData[0]) 其实就是调用了AsyncTask类中的finish方法

  private void finish(Result result) {
        if (isCancelled()) {
            onCancelled(result);
        } else {
            onPostExecute(result);
        }
        mStatus = Status.FINISHED;
    }

调用了cancel()则执行onCancelled回调；正常执行的情况下调用我们的onPostExecute(result);最后将状态置为FINISHED。

再回到mFuture

 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);
                }
            }
        };

执行 postResultIfNotInvoked(get());

    private void postResultIfNotInvoked(Result result) {
        final boolean wasTaskInvoked = mTaskInvoked.get();
        if (!wasTaskInvoked) {
            postResult(result);
        }
    }

根据 wasTaskInvoked状态判断是否执行postResult(result);
在mWorker 中我们已经知道 wasTaskInvoked.set(true)
所以该方法不会执行。

至此，AsyncTask源码分析完毕，相信大家对AsyncTask有了更深的理解~~~