AsyncTask源码分析

最新推荐文章于 2021-05-26 23:55:38 发布

原创最新推荐文章于 2021-05-26 23:55:38 发布 · 228 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#android #asynctask #源码

android 专栏收录该内容

24 篇文章

订阅专栏

本文详细剖析了Android中AsyncTask的工作原理，从构造方法到execute()方法，再到doInBackground()和onPostExecute()方法的调用过程。通过源码解读，揭示了AsyncTask如何实现线程间的任务调度和UI更新。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

接下来，我们就来分析一下AsyncTask的源码。这里我选用的是Android 4.0的源码，与其他的版本可能会有出入。

new AsyncTask< Void, Void, Void>() {}.execute();

根据上面代码顺序，我们先看一下构造方法，然后再看execcute()方法；

1、构造方法

public AsyncTask() {  
    mWorker = new WorkerRunnable<Params, Result>() {  
        public Result call() throws Exception {  
            mTaskInvoked.set(true);  
            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);  
            return postResult(doInBackground(mParams));  
        }  
    };  
    mFuture = new FutureTask<Result>(mWorker) {  
        @Override  
        protected void done() {  
            try {  
                final Result result = get();  
                postResultIfNotInvoked(result);  
            } 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);  
            } catch (Throwable t) {  
                throw new RuntimeException("An error occured while executing "  
                        + "doInBackground()", t);  
            }  
        }  
    };  
}

看上去很多，我们省略无关的，实际上就只有以下内容：

public AsyncTask() {  
    mWorker = new WorkerRunnable<Params, Result>() ;
    mFuture = new FutureTask<Result>(mWorker) ;
}

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

2、查看execute()

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

居然只有一行代码，没关系，跟着进去看看

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

这里明确可以看到第17行调用了onPreExecute()方法，因此证明了onPreExecute()方法会第一个得到执行。
但是没见到哪里调用了doInBackground()方法，不急，马上就可以找到的。
我们看到20行调用了Executor的execute()方法，Executor是一个接口，只有一个executor(Runnable runnable)方法，更由此看出mFunture是一个runnable。这两个类我们稍后详细解释。
我们从20行可以看到exec这个变量是execute()方法里传过来的一个叫sDefaultExecutor的变量，那么这个变量是什么呢？我们看看变量的定义：

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();  
……  
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

可以看到，这里先new出了一个SERIAL_EXECUTOR常量，然后将sDefaultExecutor的值赋值为这个常量，也就是说明，刚才在executeOnExecutor()方法中调用的exec.execute(mFuture)方法，其实也就是调用的SerialExecutor类中的execute()方法。那么我们就去看看SerialExecutor的execute()方法里干了什么，如下：

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

这个SerialExecutor代码的意思是，严格按照用户提交的顺序来执行任务。
我们可以看到在第9行调用了run()方法，那从上面的代码exec.execute(mFuture)中我们可以看出是调用了mFunture对象即FutureTask类的run()方法，我们在mFunture的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 {
                    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);
        }
    }

可以看到在第12行调用了callable的call()方法，而这个callable自然就是mWorker对象了，此时调的call()方法就是我们开始的构造函数中的mWorker的call()方法了：

mWorker = new WorkerRunnable<Params, Result>() {  
        public Result call() throws Exception {  
            mTaskInvoked.set(true);  
            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);  
            return postResult(doInBackground(mParams));  
        }  
};

于是我们便看到了doInBackground()方法！
虽然周转很多地方，但是当前代码依然还是在子线程中进行的。所以我们可以在doInBackground()方法中进行耗时或者网络操作，接着将doInBackground()方法返回的结果传递给了postResult()方法，这个方法的源码如下所示：

private Result postResult(Result result) {  
    Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,  
            new AsyncTaskResult<Result>(this, result));  
    message.sendToTarget();  
    return result;  
}

这里使用sHandler对象发出了一条消息，消息中携带了MESSAGE_POST_RESULT常量和一个表示任务执行结果的AsyncTaskResult对象。这个sHandler对象是InternalHandler类的一个实例，那么稍后这条消息肯定会在InternalHandler的handleMessage()方法中被处理。InternalHandler的源码如下所示：

private static class InternalHandler extends Handler {  
    @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;  
        }  
    }  
}

这里对消息的类型进行了判断，如果是MESSAGE_POST_RESULT消息，就会去执行finish()方法，如果是MESSAGE_POST_PROGRESS消息，就会去执行onProgressUpdate()方法。那么我们看看finish()方法：

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

如上，如果当前任务被取消掉了，就会调用onCancelled()方法，如果没有被取消，则调用onPostExecute()方法，这样当前任务的执行就全部结束了。

那么在刚才那个InternalHandler处理消息那里，我们还注意到有个MESSAGE_POST_PROGRESS消息类型，这种消息是用于当前进度的，调用的正是onProgressUpdate()方法，那什么时候才会发出这样一条消息呢？我们查看publishProgress()方法的源码，如下所示：

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

好了，现在我们完全清楚了吧！所以我们在doInBackground()方法中调用publishProgress()方法才可以从子线程切换到UI线程，从而完成对UI元素的更新操作。其实也没有什么神秘的，因为说到底，AsyncTask也是使用的handler异步消息处理机制，只是做了非常好的封装而已。

这里我再画个草图帮助大家理解下流程：
这里写图片描述

注意

在3.0版本中AsyncTask的改动还是挺大的，在3.0之前的AsyncTask可以同时有5个任务在执行，而3.0之后的AsyncTask同时只能有1个任务在执行。为什么升级之后可以同时执行的任务数反而变少了呢？这是因为更新后的AsyncTask已变得更加灵活，如果不想使用默认的线程池，还可以自由地进行配置。比如使用如下的代码来启动任务：

Executor exec = new ThreadPoolExecutor(15, 200, 10,  
        TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());  
new DownloadTask().executeOnExecutor(exec);

这样就可以使用我们自定义的一个Executor来执行任务，而不是使用SerialExecutor。上述代码的效果允许在同一时刻有15个任务正在执行，并且最多能够存储200个任务。

或者还可以使用

executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR)

这样就跟2.3版本的AsyncTask.execute()效果是一样的，默认5个线程同时运行。

参考：Android实战技巧：深入解析AsyncTask
Android AsyncTask完全解析，带你从源码的角度彻底理解
 AsyncTask源码分析