AsyncTask使用和源码解析

AsyncTask

介绍

在Android中提起异步通信我们都会想到Handler，之前写过一篇文章又一年对Android消息机制（Handler&Looper）的思考。Android除过使用Handler进行异步任务外，AnsyncTask也是Android原生就有的执行异步任务的关键类。
首先来看一下AsyncTask的基本用法，由于AsyncTask是一个抽象类，所以如果我们想使用它，就必须要创建一个子类去继承它。在继承时我们可以为AsyncTask类指定三个泛型参数，这三个参数的用途如下：

Params:在执行AsyncTask时需要传入的参数，可用于在后台任务中使用。
Progress:后台任务执行时，如果需要在界面上显示当前的进度，则使用这里指定的泛型作为进度单位。
Result:当任务执行完毕后，如果需要对结果进行返回，则使用这里指定的泛型作为返回值类型。

因此，一个最简单的自定义AsyncTask就可以写成如下方式：

class DownloadTask extends AsyncTask<Void, Integer, Boolean> {  
    ……  
}

这里我们把AsyncTask的第一个泛型参数指定为Void，表示在执行AsyncTask的时候不需要传入参数给后台任务。第二个泛型参数指定为Integer，表示使用整型数据来作为进度显示单位。第三个泛型参数指定为Boolean，则表示使用布尔型数据来反馈执行结果。

当然，目前我们自定义的DownloadTask还是一个空任务，并不能进行任何实际的操作，我们还需要去重写AsyncTask中的几个方法才能完成对任务的定制。经常需要去重写的方法有以下四个：

onPreExecute()
这个方法会在后台任务开始执行之间调用，用于进行一些界面上的初始化操作，比如显示一个进度条对话框等。

doInBackground(Params...)
这个方法中的所有代码都会在子线程中运行，我们应该在这里去处理所有的耗时任务。任务一旦完成就可以通过return语句来将任务的执行结果进行返回，如果AsyncTask的第三个泛型参数指定的是Void，就可以不返回任务执行结果。注意，在这个方法中是不可以进行UI操作的，如果需要更新UI元素，比如说反馈当前任务的执行进度，可以调用publishProgress(Progress...)方法来完成。

onProgressUpdate(Progress...)
当在后台任务中调用了publishProgress(Progress...)方法后，这个方法就很快会被调用，方法中携带的参数就是在后台任务中传递过来的。在这个方法中可以对UI进行操作，利用参数中的数值就可以对界面元素进行相应的更新。

onPostExecute(Result)
当后台任务执行完毕并通过return语句进行返回时，这个方法就很快会被调用。返回的数据会作为参数传递到此方法中，可以利用返回的数据来进行一些UI操作，比如说提醒任务执行的结果，以及关闭掉进度条对话框等。

执行线程

下边的日志是在 AsyncTask 每个方法执行的日志输出：

10:39:23.899#[androidcode@]#7872#E#ThreadTask--> #onPreExecute thread is main
10:39:23.900#[androidcode@]#8130#E#ThreadTask--> #doInBackground thread is AsyncTask #2
10:39:23.931#[androidcode@]#7872#E#ThreadTask--> #onProgressUpdate thread is main
10:39:23.931#[androidcode@]#7872#E#ThreadTask--> #onPostExecute thread is main

可以看到除过 doInBackground 方法外其他的方法都是在主线程中执行的。
为什么这里特意强调一下执行线程呢？因为耗时操作的处理是不能放在主线程中进行的，否则会有 ANR 问题。后面的对每个方法的源码分析的过程中会详细讲的为什么他们的线程是这样。

AsyncTask的使用

因此，一个比较完整的自定义AsyncTask就可以写成如下方式：

class DownloadTask extends AsyncTask<Void, Integer, Boolean> {  
    @Override  
    protected void onPreExecute() {  
        progressDialog.show();  
    }
    @Override  
    protected Boolean doInBackground(Void... params) {  
        try {  
            while (true) {  
                int downloadPercent = doDownload();  
                publishProgress(downloadPercent);  
                if (downloadPercent >= 100) {  
                    break;  
                }  
            }  
        } catch (Exception e) {  
            return false;  
        }  
        return true;  
    }
    @Override  
    protected void onProgressUpdate(Integer... values) {  
        progressDialog.setMessage("当前下载进度：" + values[0] + "%");  
    }
    @Override  
    protected void onPostExecute(Boolean result) {  
        progressDialog.dismiss();  
        if (result) {  
            Toast.makeText(context, "下载成功", Toast.LENGTH_SHORT).show();  
        } else {  
            Toast.makeText(context, "下载失败", Toast.LENGTH_SHORT).show();  
        }  
    }  
}

这里我们模拟了一个下载任务，在doInBackground()方法中去执行具体的下载逻辑，在onProgressUpdate()方法中显示当前的下载进度，在onPostExecute()方法中来提示任务的执行结果。如果想要启动这个任务，只需要简单地调用以下代码即可：

new DownloadTask().execute();

以上就是AsyncTask的基本用法，怎么样，是不是感觉在子线程和UI线程之间进行切换变得灵活了很多？我们并不需求去考虑什么异步消息处理机制，也不需要专门使用一个Handler来发送和接收消息，只需要调用一下publishProgress()方法就可以轻松地从子线程切换到UI线程了。

分析AsyncTask源码（Android5.1）

AsyncTask构造方法分析

public AsyncTask() {
    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            mTaskInvoked.set(true);
            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
            //noinspection unchecked
            //调用了doInBackground方法并将结果进行postResult
            return postResult(doInBackground(mParams));
        }
    };
    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 occured while executing doInBackground()",
                        e.getCause());
            } catch (CancellationException e) {
                postResultIfNotInvoked(null);
            }
        }
    };
}

初始化mWorker和mFuture，并在初始化mFuture的时候将mWorker作为参数传入。mWorker是一个Callable对象，mFuture是一个FutureTask对象，这两个变量会暂时保存在内存中，稍后才会用到它们。

启动某一任务

AsyncTask 可以多线程异步，也可以单线程异常执行：

并行

public static final Executor THREAD_POOL_EXECUTOR;
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;
}
//指定Executor为AsyncTask.THREAD_POOL_EXECUTOR
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,Params... params);

串行

private static class SerialExecutor implements Executor {
    final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
    Runnable mActive;
    public synchronized void execute(final Runnable r) {
        //调用ArrayDeque的offer()方法将传入的Runnable对象添加到队列的尾部
        mTasks.offer(new Runnable() {
            public void run() {
                try {
                    r.run();
                } finally {
                    //链式调用执行mTasks中的Runnable
                    scheduleNext();
                }
            }
        });
        //第一次调用mActive为null，自己执行循环
        if (mActive == null) {
            scheduleNext();
        }
    }
    protected synchronized void scheduleNext() {
        if ((mActive = mTasks.poll()) != null) {
            //使用THREAD_POOL_EXECUTOR去执行取出的取出的Runnable对象
            THREAD_POOL_EXECUTOR.execute(mActive);
        }
    }
}
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
//execute默认是SerialExecutor，所以只有一个工作线程
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);
}

onPreExecute的调用

AysncTask的调用非常简单，仅仅都是调用了executeOnExecutor方法：

public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
        Params... params) {
    //做检验，一个AsyncTask只能execute一次
    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执行task
    exec.execute(mFuture);
    return this;
}

onPreExecute 方法是在进入线程池之前调用的，所以它内部的方法的执行线程等于调用executeOnExecutor 方法的线程。

doInBackground的调用

分析了这么多代码看到onPreExecute的调用那么接下来正真的任务执行方法实在哪里调用的呢？
上边分析的SerialExecutor的execute方法中，执行了Runnable的run方法，那么这个Runnable实例是什么呢？

executeOnExecutor方法中的exec.execute(mFuture)；
很明显Runnable的实例就是在AsyncTask初始化时声明的FutureTask。
我们来看看FutureTask的run方法：

public void run() {
    if (state != NEW ||
        !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                     null, Thread.currentThread()))
        return;
    try {
        Callable<V> c = callable;
        if (c != null && state == NEW) {
            V result;
            boolean ran;
            try {
                //调用callable的call方法
                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);
    }
}

那么FutureTask中的Callable对象呢？就是我们在AsyncTask初始化中声明的WorkerRunable。

mWorker = new WorkerRunnable<Params, Result>() {
    public Result call() throws Exception {
        mTaskInvoked.set(true);
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        //noinspection unchecked
        //doInBackground的执行结果抛到handle主线程
        return postResult(doInBackground(mParams));
    }
};

从这里看到 doInBackground 方法是在线程池的线程中执行的。

onProgressUpdate方法的调用

如果我们需要调用onProgressUpdate在AsyncTask执行的过程中对UI进行操作，那么只需要在doInBackground方法中调用publishProgress方法，publishProgress会将中间值抛到handle主线程中。

之所以这样实现，是因为上面分析的doInBackground 是在异步线程，如果需要更新UI那么必须切换到主线程执行。这里的线程切换用的是Handle 。Handle 的详细介绍可以参考又一年对Android消息机制（Handler&Looper）的思考

protected final void publishProgress(Progress... values) {
    if (!isCancelled()) {
        getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                new AsyncTaskResult<Progress>(this, values)).sendToTarget();
    }
}
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:
                //onProgressUpdate的回调
                result.mTask.onProgressUpdate(result.mData);
                break;
        }
    }
}

onPostExecute方法的调用

上边讲述doInBackground方法的调用结束后会将结果传递给postResult方法。

private Result postResult(Result result) {
    @SuppressWarnings("unchecked")
    //postResult的result结果抛到handle主线程
    Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
            new AsyncTaskResult<Result>(this, result));
    message.sendToTarget();
    return result;
}
private static class AsyncTaskResult<Data> {
    final AsyncTask mTask;
    final Data[] mData;

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

而在InternalHandler中接受到MESSAGE_POST_RESULT消息执行了

private static class InternalHandler extends Handler {
  /*……*/
  result.mTask.finish(result.mData[0]);
  /*……*/
}

private void finish(Result result) {
    if (isCancelled()) {
        onCancelled(result);
    } else {
        //主线程将结果进行处理
        onPostExecute(result);
    }
    //状态改为结束
    mStatus = Status.FINISHED;
}

onPostExecute 和 onProgressUpdate 方法一样都是利用的 Handle 做的线程切换，所以 onPostExecute 方法内部逻辑也是在主线程执行的。

AsyncTask的cancel

取消AsyncTask的异步任务我们常用的方法是调用AsyncTask.cancel(true);但这样真的结束我们正在执行的异步任务么？

//AysncTask.java
public final boolean cancel(boolean mayInterruptIfRunning) {
    //设置取消的原子状态
    mCancelled.set(true);
    //执行当前线程的interrupt
    return mFuture.cancel(mayInterruptIfRunning);
}

在FutureTask中我们对当前线程进行中断处理interrupt。

Thread.interrupt()方法不会中断一个正在运行的线程。
这一方法实际上完成的是，在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞的状态。更确切的说，如果线程被Object.wait, Thread.join,Thread.sleep三种方法之一阻塞，那么，它将接收到一个中断异常（InterruptedException），从而提早地终结被阻塞状态。

//FutureTask.java
public boolean cancel(boolean mayInterruptIfRunning) {
    if (!(state == NEW &&
          UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
              mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
        return false;
    try {    // in case call to interrupt throws exception
        if (mayInterruptIfRunning) {
            try {
                Thread t = runner;
                if (t != null)
                    t.interrupt();
            } finally { // final state
                UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
            }
        }
    } finally {
        finishCompletion();
    }
    return true;
}

所以尽管我们调用了cancel给AsyncTask设置了一个canceled的状态，那么想要终止异步任务，就需要在异步任务当中结束。

//判断是否被取消
public final boolean isCancelled() {
    return mCancelled.get();
}

AsyncTask内部的线程池

//当前设备CPU核数
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;
//线程池的任务队列，通过线程池的 execute(Runnable command) 方法会将任务 Runnable 存储在队列中(阻塞队列)。
private static final BlockingQueue<Runnable> sPoolWorkQueue =
    //LinkedBlockingQueue一个基于链表结构的阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于 ArrayBlockingQueue。
    //静态工厂方法Executors.newFixedThreadPool()使用了这个队列。
    new LinkedBlockingQueue<Runnable>(128);
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 ThreadFactory sThreadFactory = new ThreadFactory() {
    private final AtomicInteger mCount = new AtomicInteger(1);

    public Thread newThread(Runnable r) {
        return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
    }
};
public static final Executor THREAD_POOL_EXECUTOR
    = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
        TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

AsyncTask版本间的差异

androidAPI(19)的时候AsyncTask中的线程池参数全是固定的。

//androidAPI=19
private static final int CORE_POOL_SIZE = 5;
private static final int MAXIMUM_POOL_SIZE = 128;
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>(10);

/**
 * 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);

Android 3.0之前是并没有SerialExecutor这个类，AsyncTask的执行都是并行的。

//androidAPI=10
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    if (mStatus != Status.PENDING) {123
        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;
    sExecutor.execute(mFuture);
    return this;
}

参考郭霖 Android AsyncTask完全解析，带你从源码的角度彻底理解该文章是对Android4.0的AsyncTask源码分析。

文章到这里就全部讲述完啦，若有其他需要交流的可以留言哦~！~！

最后编辑于：2021.03.15 09:35:05

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 206,968评论 6赞 482
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 88,601评论 2赞 382
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 153,220评论 0赞 344
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 55,416评论 1赞 279
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 64,425评论 5赞 374
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,144评论 1赞 285
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,432评论 3赞 401
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 37,088评论 0赞 261
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 43,586评论 1赞 300
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,028评论 2赞 325
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,137评论 1赞 334
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,783评论 4赞 324
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,343评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,333评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,559评论 1赞 262
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 45,595评论 2赞 355
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,901评论 2赞 345