AsyncTask - 基本原理 图文剖析

标签：

最近用到了AsyncTask，这玩意每个写android程序的都会用，可是不见得每个人都能用的好。如果想要用好，那么首先势必对基本原理有个大概了解。其实网上对这类问题的说明已经很多很多了，这里我就用自己的思维整理一下。

AsyncTask概述

AsyncTask是google公司封装的一个轻量级的异步任务类。实际上它内部也是通过Thread + handler实现的。如果没有AsyncTask类，我们完全可以用thread+handler来处理。这个时候就很可能自己回去封装一下thread+handler了。正是因为这类需求很多，google就帮我们封装了一下。其实我们也可以自己封装，但是我相信99%程序员自己封装的东西比不上google的。所以还是有必要学习一下AsyncTask。

AsyncTask相关的其他类

首先我们看一下AsyncTask用到了哪些主要的框架？注意，每个版本的sdk可能对AsyncTask的实现有所不同，我这里用的是Android-23.

下面是从sdk里面copy出来的AsyncTask一部分内容。

public abstract class AsyncTask<Params, Progress, Result> {
    private static final String LOG_TAG = "AsyncTask";

    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;

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

    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);

    /**
     * An {@link Executor} that can be used to execute tasks in parallel.
     */
    public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

    /**
     * An {@link Executor} that executes tasks one at a time in serial
     * order.  This serialization is global to a particular process.
     */
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

    private static final int MESSAGE_POST_RESULT = 0x1;
    private static final int MESSAGE_POST_PROGRESS = 0x2;

    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    private static InternalHandler sHandler;

    private final WorkerRunnable<Params, Result> mWorker;
    private final FutureTask<Result> mFuture;

    private volatile Status mStatus = Status.PENDING;
    ...
};

AsyncTask的数据成员主要有：

1. static Executor THREAD_POOL_EXECUTOR

2. static Executor SERIAL_EXECUTOR;

3. static Executor sDefaultExecutor; 这玩意默认指向了SERIAL_EXECUTOR。看源代码就知道了：

      private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

4. static InternalHandler sHandler;

5. WorkerRunnable<Params, Result> mWorker;

6. FutureTask<Result> mFuture;

7. Status mStatus;

这7个是AsyncTask主要的数据成员，大部分功能都跟这些成员有关。主要上述7个数据成员中，前面4个都是静态的。

THREAD_POOL_EXECUTOR & SERIAL_EXECUTOR

这两个静态实例的类分别是：ThreadPoolExecutor和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的一个内嵌类。超简单，里面就2个数据成员：mTasks和mActive。每次caller调用那个execute，就创建一个Runnable匿名内嵌类对象，这个对象存入mTasks，在匿名内嵌类的run函数里面调用传入参数r.run()。然后通过一个scheduleNext函数把mTasks里面的所有对象通过THREAD_POOL_EXECUTOR.execute(mActive)执行一遍。说穿了，也就是说SerialExecutor类会把所有的任务丢入一个容器，之后把容器里面的所有对象一个一个的排队执行THREAD_POOL_EXECUTOR.execute(mActive);

ThreadPoolExecutor就相对复杂一点了。它有几个比较重要的数据成员：核心线程数，最大线程数，缓存队列。以下上AsyncTask的一部分代码。

  
    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;

    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());
        }
    };
    private static final BlockingQueue<runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<runnable>(128);  
    public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);</runnable></runnable>

当创建ThreadPoolExecutor对象的时候，构造函数里面第一个参数就是核心线程数量，这里取得是CPU个数 + 1， 第二个参数是最大线程数量，这里是CPU个数 * 2 + 1，第五个参数是缓冲区的队列，这里是个LinkedBlockingQueue，这个队列的最大容量是128.

实际上ThreadPoolExecutor内部有个线程池概念。它的大概工作原理如下：

1. 如果正在运行的线程数量小于核心线程数量（由调用者设置，像AsyncTask就设置了cpu个数+1），那么就新创建要给线程，来执行任务（execute的传入参数）

2. 如果正在运行的线程数量大于等于核心线程数量，这个时候就分两种情况：

    a. 可以把任务丢进缓冲区，那就丢进去，等待空闲线程来执行。

    b. 如果缓冲区满了，那就看最大线程数 - 运行线程数是不是>0。如果 > 0, 就创建线程来运行新的任务。如果=0，那就丢出异常，也就是ThreadPoolExecutor不接受这个任务了。（所以使用ThreadPoolExecutor的时候需要注意异常，因为它有可能不接受任务）以下是ThreadPoolExecutor的execute代码。

    /**
     * Executes the given task sometime in the future.  The task
     * may execute in a new thread or in an existing pooled thread.
     *
     * If the task cannot be submitted for execution, either because this
     * executor has been shutdown or because its capacity has been reached,
     * the task is handled by the current {@code RejectedExecutionHandler}.
     *
     * @param command the task to execute
     * @throws RejectedExecutionException at discretion of
     *         {@code RejectedExecutionHandler}, if the task
     *         cannot be accepted for execution
     * @throws NullPointerException if {@code command} is null
     */
    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        /*
         * Proceed in 3 steps:
         *
         * 1. If fewer than corePoolSize threads are running, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         *
         * 2. If a task can be successfully queued, then we still need
         * to double-check whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         *
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
         */
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);
    }

addWork也是蛮关键的一个函数，实现如下：大概就是可以的情况下，创建线程来执行任务。

   private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get());

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

那么针对AsyncTask的情况，AsyncTask的任务是通过SerialExecutor来调用ThreadPoolExecutor的execute函数的，而SerialExecute已经通过要给容器控制任务一个一个执行了，所以这种情况下ThreadPoolExecutor只会有两种情况；

1. 没有任何线程在运行

2. 只有一个线程在运行，执行完一个任务就继续执行SerialExecutor的容器里面的下一个任务，如果有，就在当前线程里面继续执行，如果没有线程结束或者空闲。当serialExecutor有新任务来的时候，就再启动一个线程（或者用某个空闲线程）来执行任务。

总体来讲，针对AsyncTask，它有个静态数据成员SerialExecutor，

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

也就是说所有的AsyncTask对象，不管有多少个，都共享同一个SerialExecutor对象（因为它是个静态成员）。

mWorker & mFuture

其实，这两个家伙只是对Runnable和callback的一个封装。结构图：

具体细节我们不见得要去关心。当AsyncTask构造函数调用的时候，mWorker和mFuture会被创建，同时mWoker会被传入到mFuture对象里面去

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

这两个家伙的定义如下；

WorkerRunnable<Params, Result> mWorker;

FutureTask<Result> mFuture;

WorkerRunnable超简单：

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

就放了个数据成员：Params[] mParams。

那么整个流程大概是什么样子的呢？

1. 首先AsyncTask的构造函数会创建mWorker和mFuture。

2. 调用AsyncTask的execute过程如：

    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }
   public final AsyncTask<params result="" progress=""> 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();

        mWorker.mParams = params;
        exec.execute(mFuture);

        return this;
    }
</params>

（private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;）

有关WorkerRunnable和FutureTask的具体封装技巧，这里不做过多的描述，有兴趣可以自己去看，没兴趣就跳过。

调用例子

一个典型的调用如下：

        AsyncTask<Void, Void, String> asyncTask = new AsyncTask<Void, Void, String>(){
            @Override
            protected String doInBackground(Void... param)
            {
                Log.v("AsyncTask", "doInBackground");
                return "hello asyncTask";
            }

            @Override
            public void onPostExecute(String response) {
                //    callback.onSendRequestFinished(JsonUtil.jsonToBean(response, mBeanType));
                Toast.makeText(MainActivity.this, "result: " + response, Toast.LENGTH_LONG).show();
            }
        };
        asyncTask.execute();

比如我们可以在onCreate里面调用这段代码。如果我们在doInBackground里面下断点，就会看到如下调用堆栈：

最终的doInBackground是在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是WorkerRunnable的子类（匿名内嵌子类）对象，mWorker被传给了mFuture，FutureTask的 callable就是mWorker。

   public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

mFuture被传到了AsyncTask的execute里面，mFuture实际上就是Runnable的一个子类，mFuture被被SerialExecute传给ThreadPoolExecute来执行。大概流程：

1. ThreadPoolExecutor里面的一个线程执行任务（mFuture）

2. FutureTask的run()会在线程里面被执行

3. Future的run()里面会尝试获得callable，然后调用callable的call()函数。callable就是mWorker，也就是WorkRunnable，而WorkRunnable实现了接口Callable，Callable里面有个方法就是call(）。

    public void run() {
        if (state != NEW ||
            !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

4. 这样，mWorker是WorkerRunnable的子类对象，而且刚好实现了call函数，而call函数通过接口Callable在FutureTask的run()里面被调用了。所以AsyncTask的构造函数里面的匿名内嵌类里面的call实现被ThreadPoolExecutor的线程调用了。也就是这段代码：

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

就这样，AsyncTask的doInBackgroun被一个线程给调用了。

整个AsyncTask的大致流程就是这样，当然还有其他一些内容，如cancel, onPreExecute, onPostExecute, onCancelled等等，还有ThreadPoolExecutor执行完任务后，怎么通知主线程的等等问题。

画了个总体类图：可能不是很准确，但是可以看出各个类之间的关系，作为参考。

AsyncTask - 基本原理 图文剖析

标签：

原文地址：http://blog.csdn.net/zj510/article/details/51485120