android AsyncTask 源码剖析

最近 一直在看android多线程部分的源码   突然想到android中的  异步任务类 AsyncTask类  于是便看了看  它的源码  下面我就针对它的源码 分析一下它执行的过程：

首先我们先看看这个类的成员变量  

    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;   //任务执行中  这两个变量用于在handler中 接受消息并执行相应代码 

    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;  //任务执行器 
    private static InternalHandler sHandler;    // handler对象  里面有处理<span style="font-family: Arial, Helvetica, sans-serif;">MESSAGE_POST_RESULT  MESSAGE_POST_PROGRESS 的逻辑</span>


    private final WorkerRunnable<Params, Result> mWorker;   // 此类 集成 Callable接口  类似于 Runnable的作用  
    private final FutureTask<Result> mFuture;  //用于封装  mWorker  使之可以返回线程执行结果 

    private volatile Status mStatus = Status.PENDING;
      
    private final AtomicBoolean mCancelled = new AtomicBoolean();  //原子类型的变量 
    private final AtomicBoolean mTaskInvoked = new AtomicBoolean();

先来简要分析一下  首先 重写 AsyncTask类 然后调用 它的 execute函数  这个函数会调用内部的 executor类  执行execute方法(其实是执行的mfuture)

在这些方法的特定位置 调用回调接口  即可  

看execute方法 ：

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

@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();   //调用回调接口

        mWorker.mParams = params;  //参数赋值
        exec.execute(mFuture);   //执行Executor的 execute方法   其中 exec参数 是 SerialExecutor类  

        return this;
    }

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() {  //向mtasks中加入runnable 对象    其中 r是个futureTask对象 封装了一个Callable 所以实际上执行的是 callable的call方法
                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);
            }
        }
    }

 其中 r是个futureTask对象 封装了一个Callable 所以实际上执行的是 callable的call方法

所以 我们来看 

 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);   //任务执行完毕   发送消息给 handler  
            }
        };

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

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

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

这样就完成了  异步任务的调用 其实很简单  运用了线程池   

最后 看看 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);
                }
            }
        };
    }