Android AsyncTask 源码解析

是什么东西？

顾名思义，异步任务，就是说我们可以让我们异步执行任务，不过通常使用它是为了异步执行，主线程更新UI，我们都知道，Android 的UI更新操作，都会检查是否是主线程，如果不是的话就会报出异常，这一步是在ViewRootImpl里面做的，这里就不多说了。在使用的时候，我们只需要将后台处理的代码写在doInBackground，更新UI的工作写在onPostExecute就行了，就可以轻松实现一个线程切换，更新UI的效果。那这里你可能会问。为什么不用Handler，我也许会告诉你，使用 AsyncTask 有很多好处，待会会慢慢告诉你，你也可以根据源码，一探究竟。

前世今生

没有继承自任何东西，Object 除外，使用了模板定义，Params 代表你要传的参数类型，Progress 代表更新数据类型，Result 是任务执行玩返回数据类型。

public abstract class AsyncTask<Params, Progress, Result> {}

使用场景

只要需要开启子线程的都可以使用它。在项目中，随便 new Thread 并不是一个好习惯，滥用不说，很有可能造成内存泄露

实现原理大白话

有两个东西很关键，一个是线程池，一个是 Handler，线程池负责执行任务， Handler 负责通知，说道这，聪明的你大概猜到了实现方式，但这并不够，我们需要细细的品味这个类是如何写成的。

源码解析

属性

通过使用 Runtime 对象获取可用的cpu 个数，在创建线程池时创建合适的线程数量，线程池的参数主要是核心线程数，这里最小值2， 最大值4，当处理器个数为4时，创建3个核心线程数，最大线程数为 cpu个数的两倍 + 1，关于核心线程数，最大线程数，大家可自行去了解作用，以后创建线程池，大家可要记住了，以这样创建线程池数是比较合理的。KeepAliveTime 是线程存活时间，超过这个时间的线程要被回收，至于哪一些线程，待会再说

private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
// We want at least 2 threads and at most 4 threads in the core pool,
// preferring to have 1 less than the CPU count to avoid saturating
// the CPU with background work
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;

静态线程工厂，在类加载是就会被创建，里面使用了AtomicInteger 用来计数。使用了LinkedBlockingQueue作为任务队列

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;

使用静态代码块初始化线程池，参数为以上分析的数据，注意，allowCoreThreadTimeOut 设置为true，意思是允许核心线程数被回收，默认是不会被回收的

static {
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
            sPoolWorkQueue, sThreadFactory);
    threadPoolExecutor.allowCoreThreadTimeOut(true);
    THREAD_POOL_EXECUTOR = threadPoolExecutor;
}

还有一个重头戏，单任务执行器，默认不是用上面的线程池执行任务，而是使用序列执行器执行任务，意识就是，同一时刻只能执行一个任务，注意这些都是静态的，也就是说，一个进程，不管你新建了多少个 Task对象，他也只能单个任务执行，这样就很好的管理了资源，那他是如何做到单任务执行的呢，实现方式可以说是既巧妙又无语，且看注释

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static class SerialExecutor implements Executor {
    // 保存任务
    final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
    Runnable mActive;

    public synchronized void execute(final Runnable r) {
        // 新任务进来，不执行，而是使用匿名内部类创建一个Task加到任务队列里，
        // 当这个执行完的时候，才会去调用下一个任务，就做到了单任务执行。
        mTasks.offer(new Runnable() {
            public void run() {
                try {
                    r.run();
                } finally {
                    scheduleNext();
                }
            }
        });
        // 默认先
        if (mActive == null) {
            scheduleNext();
        }
    }

    // 这里是真正去执行的
    // 注意，使用到了 synchronized 的可重入特性！
    protected synchronized void scheduleNext() {
        if ((mActive = mTasks.poll()) != null) {
            THREAD_POOL_EXECUTOR.execute(mActive);
        }
    }
}

一些静态的变量基本看完了，下面来看一下构造函数，有点长

/**
 * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
 *
 * @hide
 */
public AsyncTask(@Nullable Looper callbackLooper) {
    // 首先获取 Handler 对象，这里有主线程 Handler 和子线程Handler 之分
    mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
        ? getMainHandler()
        : new Handler(callbackLooper);

    // 异步执行的，实现了callable接口
    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            // 为了防止多次多次调用实例
            mTaskInvoked.set(true);
            Result result = null;
            try {
                // 设置进程的优先级
                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                // noinspection unchecked
                // 在这里执行doInBackground函数，
                // 这是我们需要重写的
                result = doInBackground(mParams);
                Binder.flushPendingCommands();
            } catch (Throwable tr) {
                mCancelled.set(true);
                throw tr;
            } finally {
                // 执行完，这里还是在子线程
                postResult(result);
            }
            return result;
        }
    };

    // FutureTask 对象，封装Callable 对象
    mFuture = new FutureTask<Result>(mWorker) {
        // 结束时调用
        @Override
        protected void done() {
            try {
                // 如果没有被调用的话，通过get获取结果
                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);
            }
        }
    };
}

执行完以后，使用Handler 进行通知，注意，这里将结果装入Message对象中，直接发送。一个小技巧，我们在发送消息是尽可能使用 obtainMessage 获取Message对象要比new一个好得多。

// 返回结果，使用handler
private Result postResult(Result result) {
    @SuppressWarnings("unchecked")
    Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
            new AsyncTaskResult<Result>(this, result));
    message.sendToTarget();
    return result;
}

那执行入口呢? MainThread 代表主线程执行

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

    return this;
}

一些我们可能需要实现的函数

//   我们将后台逻辑写在这里
@WorkerThread
protected abstract Result doInBackground(Params... params);

@MainThread
protected void onPreExecute() {
}
// 执行完回调
@MainThread
protected void onPostExecute(Result result) {
}
// 如果有进度条更新
@MainThread
protected void onProgressUpdate(Progress... values) {
}

@MainThread
protected void onCancelled() {
}

如何更新进度条？只需要在 doInBackground 中调用即可，将参数传入，使用handler机制

@WorkerThread
protected final void publishProgress(Progress... values) {
    if (!isCancelled()) {
        getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                new AsyncTaskResult<Progress>(this, values)).sendToTarget();
    }
}

Handler 处理消息的地方，静态类

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

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

当然，你也可以取消任务，不过只能取消还没执行的任务，底层是调用 thread.interrupt 方法，简单粗暴，关于他的使用，可以写一堆东西来说，这里暂且不展开说

public final boolean cancel(boolean mayInterruptIfRunning) {
    mCancelled.set(true);
    return mFuture.cancel(mayInterruptIfRunning);
}

当然，如果不要于UI交互，你也可以使用这个执行后台逻辑，直接调用executeOnExecutor，使用静态的execute提交，这里是单任务的

public static void execute(Runnable runnable) {
        sDefaultExecutor.execute(runnable);
    }

当然，也可以多任务一起执行，调用executeOnExecutor时指定内部的线程池即可AsyncTask.THREAD_POOL_EXECUTOR

总结

我们了解这AsyncTask这个类，大致知道了他是怎么实现了，如果要进一步了解的话，线程池，锁这些东西必不可少的～

如有错误，欢迎讨论