AsyncTask分析

前言

Android为了提高运行流程性不允许主线程阻塞，所以耗时操作都要在子线程执行，耗时操作完成后再通知主线程完成回调。而AsyncTask就是google官方封装好的一个轻量级异步框架。AsyncTask也用了很久了，这几天在做些网络、线程池相关的东西时又回过来重新学习了下AsyncTask源码，记录一下。

使用方法

Android的异步回调一般都是通过创建worker线程执行任务，完成后通过handler通知主线程完成后续操作。其实不用AsyncTask而直接用Handler也是一样的，不过通过AsyncTask可以简化代码，让代码结构变得更加清晰。
先来看看AsyncTask的定义：

public abstract class AsyncTask {

三种泛型类型分别代表“启动任务执行的输入参数”、“后台任务执行的进度”、“后台计算结果的类型”。在特定场合下，并不是所有类型都被使用，如果没有被使用，可以用java.lang.Void类型代替。
一个异步任务的执行一般包括以下几个步骤：
1.execute(Params... params)，执行一个异步任务，需要我们在代码中调用此方法，触发异步任务的执行。
2.onPreExecute()，在execute(Params... params)被调用后立即执行，一般用来在执行后台任务前对UI做一些标记。
3.doInBackground(Params... params)，在onPreExecute()完成后立即执行，用于执行较为费时的操作，此方法将接收输入参数和返回计算结果。在执行过程中可以调用publishProgress(Progress... values)来更新进度信息。
4.onProgressUpdate(Progress... values)，在调用publishProgress(Progress... values)时，此方法被执行，直接将进度信息更新到UI组件上。
5.onPostExecute(Result result)，当后台操作结束时，此方法将会被调用，计算结果将做为参数传递到此方法中，直接将结果显示到UI组件上。

实现原理

线程池：

作为异步请求框架，创建线程肯定是毫无疑问的，android2.3以上AsyncTask有两个线程池：
先来看看第一个并行线程池

  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 sPoolWorkQueue =
            new LinkedBlockingQueue(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);

这里google对不同性能的手机做了适配，根据cpu核数的不同线程池的coreSize和MaxSize值不同，在线程数达到coreSize之前，添加到线程池的任务会立即执行，而线程数到达coreSize后会被添加到阻塞队列sPoolWorkQueue 中，如果队列满才会开启新的线程，直到线程数达到maxSize且队列也满了后线程池就会拒绝接受任务（调用RejectedExecutionHandler来处理），当然任务数一般也很难达到这个上限。

而调用execute（）执行asynctask则使用的是串行线程池，源码如下：

private static class SerialExecutor implements Executor {
        final ArrayDeque mTasks = new ArrayDeque();
        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 其实也是执行在并行线程池上，这里用了一个数组实现的双端队列，当一个任务执行完了再取队列尾的任务执行，这样就实现了串行执行的功能。

2.任务的执行
AsyncTask的执行是通过execute（）和executeonexecutor（）两个方法，execute（）在Android2.3之后是串行的，而在Android2.3之前（包括2.3）是并行的。而execute其实也是调用的executeonexecutor（），只不过worker线程池是SerialExecutor 罢了。先来看看executeOnExecutor的源码：

 @MainThread
    public final AsyncTask 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;
    }

上面大部分代码是一些异常判定和状态设置，而倒数第三行才是真正的执行部分，那mFuture是什么呢？

public AsyncTask() {
        mWorker = new WorkerRunnable() {
            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(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);
                }
            }
        };
    }

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

    private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult(this, result));
        message.sendToTarget();
        return result;
    }

由上面的代码可以看到，mWoker是对doInBackground（）中任务的封装，而mFuture 则是实现了Future和Runnable的，Future接口主要的以下功能：
1）判断任务是否完成；
2）能够中断任务；
3）能够获取任务执行结果。
上面的三个功能正是我们对AsyncTask的一些需求，所以选用FutureTask的确是很好的选择。

上面的代码最后是走到了postResult（）方法这里，其实就是简单的通过Handler把result发送到主线程并执行onPostExecute（）方法。来看看Handler的定义：

private static Handler getHandler() {
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                sHandler = new InternalHandler();
            }
            return sHandler;
        }
    }

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

这个Handler是一个使用了主线程的mainlooper的静态handler，而且是单例的（其实可以通过双重校验锁来减小点同步的范围的），注意：在4.1以前这个handler并没有设置mainlooper，而是在第一次实例化AsyncTask的线程初始化的，所以初始化的现成必须是主线程。

结语

虽然AsyncTask只是很简单的框架，不过也能学到很多源码的细节，如线程池的设置、atomicboolean实现原子性、Future类实现任务的控制等等。

AsyncTask分析

前言

使用方法

实现原理

结语

你可能感兴趣的:(AsyncTask分析)