AsyncTask源码解析

AsyncTask是一个抽象类

作用：

在主线程中调用，会在后台开启一个线程执行任务，任务的进度可以与主线程交互。

原理：

AsyncTask内部封装了线程池和handler。线程池创建线程执行任务，通过handler与主线程交互。

调用方式：

泛型参数：

 AsyncTask<Parms,Progress,Result> 

Parms 任务执行的参数类型

Progress 任务进度的参数类型

Result 返回结果的参数类型

常用的方法：

doinBackground()  执行耗时任务

publishProgress() 将任务进度交给onProgressUndate()

onProgressUpdate() 更新主线程界面

onPostExecute() 任务执行完成返回结果。

请查看下面的代码，有简单注释（重点是源码的解析）

 AsyncTask<String,String,String> asyncTask = new AsyncTask<String, String, String>() {
            @Override
            /*子线程
            后台子线程执行的任务
            * */
            protected String doInBackground(String... params) {
                publishProgress("");//将任务进度提交给onProgressUpdata()方法，

                return null;
            }

            @Override
            /*UI线程
            与UI线程交互
            * */
            protected void onProgressUpdate(String... values) {
                super.onProgressUpdate(values);
            }

            @Override
            /*UI线程
            * 任务完成后执行的
            * */
            protected void onPostExecute(String s) {
                super.onPostExecute(s);
            }

            @Override
            /*
            * UI线程
            * 在doInBackground方法之前被调用 可以做一些初始化工作
            * */
            protected void onPreExecute() {
                super.onPreExecute();
            }

            @Override
            /*
            * 任务执行中断
            * */
            protected void onCancelled(String s) {
                super.onCancelled(s);
            }

            @Override
              /*
            * 任务执行中断
            * */
            protected void onCancelled() {
                super.onCancelled();
            }
        };
        asyncTask.execute("HELLO");

AsyncTask源码

下面先上AsyncTask的源代码，然后再根据代码解释

源码中我已经做了详细的注释，这里就不过多的赘述了，注释若有不正确的地方欢迎指教。每个人看源代码的方式会有所不同，根据使用方法去看源代码会比较清晰省时：先看构造方法，然后看调用的方法。

package android.os;

import android.annotation.MainThread;
import android.annotation.WorkerThread;

import java.util.ArrayDeque;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
/*
*抽象类，异步执行任务，并与主线程交互
内部封装线程池和handler。
三个泛型参数依次代表任务执行的开始参数类型，过程参数类型，结束参数类型
*
*/
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 = Math.max(2, Math.min(CPU_COUNT - 1, 4));//核心线程数
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;//最大线程数
    private static final int KEEP_ALIVE_SECONDS = 30;//空闲线程的存活时间，

    private static final ThreadFactory sThreadFactory = new ThreadFactory() {//线程工厂：创建任务线程线程
        private final AtomicInteger mCount = new AtomicInteger(1);//原子integer，线程安全（具有阻塞的作用）

        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());//创建线程，mCount自动加1
        }
    };

    private static final BlockingQueue<Runnable> sPoolWorkQueue = //队列中存放要执行的任务，具有线程安全阻塞的作用
            new LinkedBlockingQueue<Runnable>(128);//最大允许存储128个Runnable任务。

    /**
     * An {@link Executor} that can be used to execute tasks in parallel.
     */
    public static final Executor THREAD_POOL_EXECUTOR;//线程池，执行多个任务

    static {
/*
*在静态代码块中对线程池进行初始化并保存在变量threadPoolExecutor上。
*/
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(//创建线程池
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);//允许线程空闲退出
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }

   
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();//创建串行线程池，单个任务

    private static final int MESSAGE_POST_RESULT = 0x1;//在InternalHandler 中用到。表示任务已经结束，有返回值了
    private static final int MESSAGE_POST_PROGRESS = 0x2;//也是在InternalHandler中用到。表示要与主线程交互

    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;//默认线程是SerialExecutor()
    private static InternalHandler sHandler;//用于处理与主线程交互和任务结束，

    private final WorkerRunnable<Params, Result> mWorker;//任务
    private final FutureTask<Result> mFuture;//处理任务：取消任务，执行任务，返回结果。。。

    private volatile Status mStatus = Status.PENDING;//默认任务所处待定状态
    
    private final AtomicBoolean mCancelled = new AtomicBoolean();//原子性线程安全，任务是否取消了
    private final AtomicBoolean mTaskInvoked = new AtomicBoolean();//原子性线程安全，任务是否被调用

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

    /**
     *任务执行的状态
     */
    public enum Status {
        /**
         * ,待定
         */
        PENDING，
        /**
         * 正在执行
         */
        RUNNING, 
        /**
         * 完成
         */
        FINISHED,
    }
/**
*//获取handler,没有则重新创建
*
*/
    private static Handler getHandler() {
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                sHandler = new InternalHandler();
            }
            return sHandler;
        }
    }

    /*
     * 设置线程池 
    */
    public static void setDefaultExecutor(Executor exec) {
        sDefaultExecutor = exec;
    }

    /**
     * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
创建一个新的异步任务，且必须在主线程中创建，因为要与主线程交互，
     */
    public AsyncTask() {
        mWorker = new WorkerRunnable<Params, Result>() {//实现了Callable接口
            public Result call() throws Exception {
                mTaskInvoked.set(true);//任务已经被调用

                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);//设置线程优先级
                //noinspection unchecked
                Result result = doInBackground(mParams);//将mParams传入到后台onInBackground中执行，一般重写此方法自//定义任务。结果存到result变量中
                Binder.flushPendingCommands();
                return postResult(result);//postResult(result)作为返回结果并发送消息到主线程的handler
            }
     };

/**       
将上面的mWorker作为参数 FutureTask<V>实现了RunnableFuture<V>,而RunnableFuture<V>继承Runnable和Future.
*/所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。
        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);
                }
            }
        };
    }

//判断任务是否已经调用，如果没有调用则执行postResult
    private void postResultIfNotInvoked(Result result) {
        final boolean wasTaskInvoked = mTaskInvoked.get();
        if (!wasTaskInvoked) {
            postResult(result);
        }
    }

/**
*发送消息到主线程的handler 让handlerMessage处理
*
*/
    private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

    /**
    获取当前任务处于什么状态
     */
    public final Status getStatus() {
        return mStatus;
    }

    /**
    任务执行
     */
    @WorkerThread
    protected abstract Result doInBackground(Params... params);

    /**
     任务处理开始之前调用，
     */
    @MainThread
    protected void onPreExecute() {
    }

    /**
    任务处理完成。
     */
    @SuppressWarnings({"UnusedDeclaration"})
    @MainThread
    protected void onPostExecute(Result result) {
    }

    /**
    与主线程交互
     */
    @SuppressWarnings({"UnusedDeclaration"})
    @MainThread
    protected void onProgressUpdate(Progress... values) {
    }

    /**
   任务取消完成，有返回值
     */
    @SuppressWarnings({"UnusedParameters"})
    @MainThread
    protected void onCancelled(Result result) {
        onCancelled();
    }    
    
    /**
    任务取消完成 
     */
    @MainThread
    protected void onCancelled() {
    }

    /**
    任务是否取消了
     * @see #cancel(boolean)
     */
    public final boolean isCancelled() {
        return mCancelled.get();
    }

    /**
    取消任务 返回值boolean 
true 表示已经取消
mayInterruptIfRunning 是否取消正在执行的任务
     */
    public final boolean cancel(boolean mayInterruptIfRunning) {
        mCancelled.set(true);
        return mFuture.cancel(mayInterruptIfRunning);
    }

    /**
   获取任务执行的返回值，如果没有则阻塞等待
     */
    public final Result get() throws InterruptedException, ExecutionException {
        return mFuture.get();
    }

    /**
       在timeout时间内取出任务中的返回值，如果超过此时间则会抛异常
     */
    public final Result get(long timeout, TimeUnit unit) throws InterruptedException,
            ExecutionException, TimeoutException {
        return mFuture.get(timeout, unit);
    }

    /**
   
//并行执行任务
     */
    @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();//作为初始化使用，在doingBackground方法前面执行

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

        return this;
    }

    /**
    
     *串行执行任务
     */
    @MainThread
    public static void execute(Runnable runnable) {
        sDefaultExecutor.execute(runnable);
    }

   
    /*
     *同过此方法可以将doinBackground方法中执行的过程传递到#onProgressUpdate，更新UI线程
     */
    @WorkerThread
    protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }
/**
*在InternalHandler MESSAGE_POST_RESULT:被调用。
*/
    private void finish(Result result) {
        if (isCancelled()) {//任务是否终端
            onCancelled(result);中断则执行此方法
        } else {
            onPostExecute(result);//没有则执行此方法
        }
        mStatus = Status.FINISHED;//状态设为完成
    }
/**
*
*
*
*/
    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;//内部参数为asyncTask
            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;
            }
        }
    }

/**

*线程并发库。实现了Callable接口，相当于Runnable，区别：带有返回值
*
*
*/
    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }

    @SuppressWarnings({"RawUseOfParameterizedType"})
    private static class AsyncTaskResult<Data> {
        final AsyncTask mTask;
        final Data[] mData;

        AsyncTaskResult(AsyncTask task, Data... data) {
            mTask = task;
            mData = data;
        }
    }
}