Android | AsyncTask源码分析

最新推荐文章于 2024-09-12 08:55:39 发布

chongyucaiyan

最新推荐文章于 2024-09-12 08:55:39 发布

阅读量3.2k

点赞数 1

分类专栏： Android源码文章标签： android

本文链接：https://blog.csdn.net/u012317510/article/details/78858911

版权

Android源码专栏收录该内容

6 篇文章 0 订阅

订阅专栏

前言

当应用需要执行耗时的任务时，为了保持应用的平滑流畅和避免ANR，我们需要使用工作线程来执行耗时的任务。当耗时的任务执行完毕时，如果需要更新UI界面，那么我们需要使用Handler来通知UI线程更新界面。为了简化这些操作，方便开发人员编程，Android系统提供了一个AsyncTask类。使用AsyncTask，你可以很方便地执行后台操作，并在UI线程中更新界面，而无需直接操作Thread和Handler类。

基础知识

AsyncTask的工作原理主要涉及到了多线程、线程池和Handler消息机制等基础知识，具体这些基础知识可以阅读下面这些文章：

基本用法

AsyncTask的定义如下所示：

public abstract class AsyncTask<Params, Progress, Result> {
    ...
    @MainThread
    protected void onPreExecute() {
    
    }
    
    @WorkerThread
    protected abstract Result doInBackground(Params... params);
    
    @WorkerThread
    protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            getHandler().obtainMessage(MESSAGE_POST_PROGRESS, new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }
    
    @MainThread
    protected void onProgressUpdate(Progress... values) {
    
    }
    
    @MainThread
    protected void onPostExecute(Result result) {
    
    }
    
    @MainThread
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }    
    ...
}

可以看到，AsyncTask是一个有3个泛型类型的抽象类。3个泛型类型的说明如下所示：

Params，传递给后台操作的参数的类型。
Progress，后台操作的进度的类型。
Result，后台操作的结果的类型。

如果某个泛型没有用到，那么可以使用 Void 类型。

为了使用AsyncTask，首先，我们需要定义一个继承自它的类，并重写doInBackground()方法，在 doInBackground() 方法中编写耗时的后台操作。如果需要执行一些初始化操作，那么可以重写 onPreExecute() 方法。如果需要在界面上更新后台操作的进度，那么可以重写 onProgressUpdate() 方法，并在doInBackground()方法中调用publishProgress()方法发送进度。如果需要在后台操作结束时更新界面，那么可以重写 onPostExecute() 方法。然后，在UI线程中创建一个该类的对象。最后，在UI线程中调用该对象的execute()方法。

示例代码如下所示：

private class DownloadFilesTask extends AsyncTask<String, Integer, Long> {

    @Override
    protected Long doInBackground(String... urls) {
        int count = urls.length;
        long totalSize = 0;
        for (int i = 0; i < count; i++) {
            totalSize += Downloader.downloadFile(urls[i]);
            publishProgress((int) ((i / (float) count) * 100));
            if (isCancelled()) {
                break;
            }
        }
        
        return totalSize;
    }
    
    @Override
    protected void onProgressUpdate(Integer... progress) {
        updateProgress(progress[0]);
    }
    
    @Override
    protected void onPostExecute(Long result) {
        updateResult(result);
    }
}

// 创建并执行AsyncTask
new DownloadFilesTask().execute(url1, url2, url3);

源码分析

首先，我们来看AsyncTask的构造方法：

public abstract class AsyncTask<Params, Progress, Result> {
    ...
    public AsyncTask() {
        this((Looper) null);
    }
    
    public AsyncTask(@Nullable Looper callbackLooper) {
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);
        ...
    }    
    
    private static Handler getMainHandler() {
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                sHandler = new InternalHandler(Looper.getMainLooper());
            }
            return sHandler;
        }
    }    
    ...
}

通常，我们会调用AsyncTask无参的构造方法，该方法调用了带Looper参数的构造方法。此时，callbackLooper参数为null，AsyncTask会调用getMainHandler()静态方法来获取与UI线程相关联的Handler，并赋值给mHandler成员变量。这样，当通过mHandler发送消息时，最终会在UI线程中处理发送的消息。从getMainHandler()静态方法的代码可以知道，mHandler是一个InternalHandler类型的Handler对象。我们后面再分析InternalHandler，先接着看AsyncTask的构造方法：

public abstract class AsyncTask<Params, Progress, Result> {
    ...
    public AsyncTask(@Nullable Looper callbackLooper) {
        ...
        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
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    postResult(result);
                }
                return 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);
                }
            }
        };
    }    
    
    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }
    ...
}

AsyncTask的构造方法接着创建了一个WorkerRunnable和一个FutureTask对象，并分别赋值给了mWorker和mFuture成员变量。WorkerRunnable是一个实现了Callable接口的抽象类，当任务被提交给线程池时，call()方法将在线程池的工作线程中执行。FutureTask通常与Callable接口配合使用，当任务正常执行完毕或者被取消时，done()方法将被回调。FutureTask可以管理任务的生命周期，比如，调用get()方法可以获取任务的执行结果，调用cancel()方法可以取消任务等。

在call()方法中，doInBackground()方法被调用。因此，doInBackground()方法是在工作线程中执行的，我们可以在该方法中执行耗时的后台操作。当后台操作执行完毕时，会调用postResult()方法将后台操作的结果发送出去。在done()方法中，postResultIfNotInvoked()方法被调用，该方法也调用了postResult()方法。done()方法的主要作用是，由于取消任务造成call()方法未被执行时，AsyncTask可以回调onCancelled()方法。我们接着来看postResult()方法：

public abstract class AsyncTask<Params, Progress, Result> {
    ...
    private Result postResult(Result result) {
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }
    
    private Handler getHandler() {
        return mHandler;
    }    
    
    private static class AsyncTaskResult<Data> {
        final AsyncTask mTask;
        final Data[] mData;

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

postResult()方法调用了getHandler()方法来获取mHandler对象，然后使用mHandler发送了一条包含了后台操作结果的消息。这条消息的what字段值为MESSAGE_POST_RESULT，obj字段为后台操作的结果，它是一个AsyncTaskResult对象。前面分析过，mHandler是一个InternalHandler类型的Handler对象。所以，我们接着来看InternalHandler类中处理消息的代码：

public abstract class AsyncTask<Params, Progress, Result> {
    ...
    private static class InternalHandler extends Handler {
        ...
        @Override
        public void handleMessage(Message msg) {
            AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
            switch (msg.what) {
                case MESSAGE_POST_RESULT:
                    result.mTask.finish(result.mData[0]);
                    break;
                ...
            }
        }
    }
    
    private void finish(Result result) {
        if (isCancelled()) {
            onCancelled(result);
        } else {
            onPostExecute(result);
        }
        mStatus = Status.FINISHED;
    }    
    ...
}

mHandler是一个与UI线程相关联的Handler对象，所以InternalHandler中的handleMessage()方法是在UI线程中执行的。handleMessage()方法对what字段值为MESSAGE_POST_RESULT的消息进行了处理，调用了AsyncTask的finish()方法，最终调用了onPostExecute()方法。因此，onPostExecute()方法是在UI线程中执行的，我们可以在该方法中将后台操作的结果直接更新到界面中。

当我们在doInBackground()方法中执行耗时的后台操作时，可以调用publishProgress()方法来发送后台操作的进度。所以，我们接着来看publishProgress()方法：

public abstract class AsyncTask<Params, Progress, Result> {
    ...
    @WorkerThread
    protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }
    
    private static class InternalHandler extends Handler {
        ...
        @Override
        public void handleMessage(Message msg) {
            AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
            switch (msg.what) {
                ...
                case MESSAGE_POST_PROGRESS:
                    result.mTask.onProgressUpdate(result.mData);
                    break;
            }
        }
    }    
    ...
}

与postResult()方法类似，publishProgress()方法使用mHandler对象发送了一条包含了后台操作进度的消息。这条消息的what字段值为MESSAGE_POST_PROGRESS，obj字段为后台操作的进度，它是一个AsyncTaskResult对象。InternalHandler的handleMessage()方法对what字段值为MESSAGE_POST_PROGRESS的消息进行了处理，调用了AsyncTask的onProgressUpdate()方法。因此，onProgressUpdate()方法是在UI线程中执行的，我们可以在该方法中将后台操作的进度直接更新到界面中。

然后，我们来看AsyncTask的execute()方法：

public abstract class AsyncTask<Params, Progress, Result> {
    ...
    @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;
    }    
    ...
}

execute()方法必须在UI线程中调用，它调用了executeOnExecutor()方法。在executeOnExecutor()方法的开始处对AsyncTask的状态进行了判断，如果当前状态不是初始的Status.PENDING状态，那么就抛出异常。因此，一个AsyncTask任务只能执行一次。然后，调用了onPreExecute()方法。因此，onPreExecute()方法是在UI线程中执行的，我们可以在该方法中进行一些初始化操作。最后，调用Executor参数的execute()方法将包含了任务的mFuture成员变量提交到sDefaultExecutor中。sDefaultExecutor是一个默认的执行器，它决定了任务将如何执行。所以，我们接着来看sDefaultExecutor相关的代码：

public abstract class AsyncTask<Params, Progress, Result> {
    ...
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

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

sDefaultExecutor是一个SerialExecutor。当调用execute()方法提交一个任务时，任务将被添加到ArrayDeque队列的队尾。如果当前没有执行中的任务，那么将调用scheduleNext()方法来取出队首的一个任务来执行。每个任务执行完毕时也会调用scheduleNext()方法来取出队首的一个任务来执行。因此，SerialExecutor是一个采用了队列的串行执行器。所有调用execute()方法执行的AsyncTask都将串行执行。scheduleNext()方法最终将任务提交给了THREAD_POOL_EXECUTOR。所以，我们接着来看THREAD_POOL_EXECUTOR相关的代码：

public abstract class AsyncTask<Params, Progress, Result> {
    ...
    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);

        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };

    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);

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

可以看到，THREAD_POOL_EXECUTOR就是一个线程池。因此，AsyncTask中的后台操作最终是在线程池的工作线程中执行的。如果需要并行地执行AsyncTask，那么可以调用AsyncTask的executeOnExecutor()方法，并将Executor参数指定为THREAD_POOL_EXECUTOR线程池或者自定义的线程池。

总结

当执行AsyncTask时，主要会经历以下4个方法：

onPreExecute()，执行后台操作之前，在 UI线程 中调用。这个方法通常用于进行一些初始化操作。例如，在UI界面上显示一个进度条。
doInBackground(Params… params)，onPreExecute()方法执行完毕之后，在 工作线程 中调用。这个方法用于执行耗时的后台操作。AsyncTask的参数被传递给这个方法。后台操作的结果由这个方法返回，并被传递给onPostExecute()方法。这个方法中还可以调用publishProgress()方法来发送后台操作的进度。
onProgressUpdate(Progress… values)，调用publishProgress()方法之后，在 UI线程 中调用。这个方法通常用于在UI界面上更新后台操作的进度。例如，在UI界面上更新一个进度条。publishProgress()方法传递的进度作为参数传递给了这个方法。
onPostExecute(Result result)，后台操作完成之后，在 UI线程 中调用。这个方法通常用于在UI界面上更新后台操作的结果。后台操作的结果作为参数传递给了这个方法。

最后，AsyncTask应该用于耗时短的操作（最多几秒钟）。

参考

Android 8.0 (API level 26)
https://developer.android.com/reference/android/os/AsyncTask.html

chongyucaiyan

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Android | AsyncTask源码分析

当应用需要执行耗时的任务时，为了保持应用的平滑流畅和避免ANR，我们需要使用工作线程来执行耗时的任务。当耗时的任务执行完毕时，如果需要更新UI界面，那么我们需要使用Handler来通知UI线程更新界面。为了简化这些操作，方便开发人员编程，Android系统提供了一个AsyncTask类。使用AsyncTask，你可以很方便地执行后台操作，并在UI线程中更新界面，而无需直接操作Thread和Handler类。
复制链接

扫一扫

专栏目录