深入理解AsyncTask

最新推荐文章于 2021-06-07 21:40:14 发布

reakingf

最新推荐文章于 2021-06-07 21:40:14 发布

阅读量810

点赞数

分类专栏： android 文章标签： asynctask 线程异步消息处理

本文链接：https://blog.csdn.net/reakingf/article/details/53456269

版权

android 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

在Android中，异步消息处理机制除了Thread+Handler（还不懂Handler机制的看这里：深入理解Android中的Handler机制）外，还提供了AsyncTask这个轻量级（代码编写上较轻量级，实际更耗资源）的异步任务类方便我们异步处理消息，它可以使我们无需通过操作新线程和Handler并能在后台执行耗时操作，并将执行结果甚至执行的程度显示到 UI 线程上。
我们先来熟悉AsyncTask，然后再从源码层对其工作原理进行分析。

初步熟悉

先比较下AsyncTask与Handler机制，
AsyncTask的优点：
1. 使用起来更加简单、快捷；
2. 可以控制后台任务的执行过程。
缺点：
1. 在使用多个异步操作和需要进行UI变更时，会变得相对更复杂。

Handler的优点：
1. 结构更加清晰，功能定义更加明确；
2. 对于执行多个后台任务更加清晰、简单。
缺点：
1. 执行单个任务代码量相对较多，结构相对复杂些。

而实际上，AsyncTask的实现原理是一个线程池，同时内部使用的还是Handler机制，所以也可以说AsyncTask是对handler机制的一个封装，我们先来简单的看下它的用法，通过创建一个继承于AsyncTask的子类来实现异步任务，这里假设是一个文件下载任务，如下：

 private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
     protected Long doInBackground(URL... 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));
             // Escape early if cancel() is called
             if (isCancelled()) break;
         }
         return totalSize;
     }

     protected void onProgressUpdate(Integer... progress) {
         setProgressPercent(progress[0]);
     }

     protected void onPostExecute(Long result) {
         showDialog("Downloaded " + result + " bytes");
     }
 }

创建完就可以执行了，执行的方法很简单，但需要注意的是，一定得在UI线程中加载这个AsyncTask且创建它的实例并执行，只能执行一次，不然会抛出异常。执行方法如下：

//UI线程中
 new DownloadFilesTask().execute(url1, url2, url3);

这里可以看到在继承AsyncTask时传入了3个参数，分别是：
1. Params：传给后台任务执行所用的参数。
2. Progress：后台任务执行过程公布的进度。
3. Result：后台任务执行完的结果。
但其实并不是一定要参数这三个参数的，看实际需要而定，如果不需要用到，可以这样：

 private class MyTask extends AsyncTask<Void, Void, Void> { ... }

调用 execute 方法后，AsyncTask会执行以下4个主要步骤（均不允许手动调用）：

onPreExecute：在异步任务开始执行前会在主线程中被自动调用。该方法常用于做一些任务初始化显示，如显示个进度对话框通知用户正在进入后台任务等。
doInBackground：在onPreExecute()方法执行完会在后台线程自动调用，但因为是在后台线程中执行，所以不允许进行UI操作，即该方法只用于执行后台的耗时操作，它会获取异步任务传进来的第一个参数进行处理。而其执行完的结果会通过onPostExecute方法显示出来，同时，可以在该方法中调用publishProgress(Progress...)方法并传入后台任务的执行进度，然后publishProgress会自动调用onProgressUpdate(Progress...)方法最终将进度显示出来。
onProgressUpdate ：在publishProgress(Progress...)被调用后会在UI线程中被自动调用。该方法用于publishProgress(Progress...)传进来的进度通知给用户，例如通过一个动态的进度对话框通知用户后台任务的执行情况。
onPostExecute：在后台任务执行完后由UI线程自动调用，会将doInBackground的执行结果作为参数传进来处理，可用于通知用户任务已执行完成。

当然，我们前面也说过，AsyncTask的优点之一就是过程可控。当我们突然间想取消后台任务是，可以通过调用cancel(boolean)方法将任务取消。调用该方法将会导致isCancel()返回true，然后导致doInBackground(Object[]) 执行完调用onCancelled(Object) 而不是onPostExecute(Object) 对结果进行处理。为了使任务能够尽快取消，我们应该在doInBackground 中常去检查isCanceled() 的返回值，如在每个循环中都进行一次判断，可以参考上面的例子。

源码解析

接下来我们通过AsyncTask的源码对其工作原理进行分析。首先是通过execute方法开始启动任务。

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

从上面可以看出，每个异步任务实例只能执行一次，若执行多次则会抛出对应的异常。若是第一次进入，则修改器mStatus 属性为RUNNING，然后执行onPreExecute 方法，因为该方法是运行于mainThread中的，所以onPreExecute 同样也是运行于mainThread上。接着将我们传入的参数赋值给mWorker.mParams，最后执行exec.execute(mFuture)。

接下来我们先来看看这个mWorker和mFuture。

private final WorkerRunnable<Params, Result> mWorker;
private final FutureTask<Result> mFuture;

private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
    Params[] mParams;
}

可以看到，mWork其实是Callable的子类，且包含一个mParams用于保存我们传进来的参数，而mFuture同样是一个实现了RunnableFuture接口的FutureTask实例，而接口RunnableFuture又实现了Runnable和Future接口（java.util.concurrent包下的接口），由于代码量较多，这里不展开，简单的说，它是一个过程可控的异步任务类，可用于封装一个Callback或一个Runnable，并交给线程池执行。

public AsyncTask() {
    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            mTaskInvoked.set(true);

            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
            //noinspection unchecked
            Result result = doInBackground(mParams);
            Binder.flushPendingCommands();
            return postResult(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);
            }
        }
    };
}

mWorker在AsyncTask的构造函数中进行初始化，并实现它的call方法。在call方法中，设置mTaskInvoked.set(true)（在mFuture中会用到），再调用doInBackground方法，并将其返回值做为postResult的参数处理。

@WorkerThread
protected abstract Result doInBackground(Params... params);

private Result postResult(Result result) {
    @SuppressWarnings("unchecked")
    Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
            new AsyncTaskResult<Result>(this, result));
    message.sendToTarget();
    return result;
}

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

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

doInBackground 由我们自己实现；再看看postResult ，很明显，这就是我们熟悉的Handler机制啦，传递一个message，且message.what=MESSAGE_POST_RESULT, message.obj = new AsyncTaskResult(this, result))，而AsyncTaskResult就是一个带有一个AsyncTask和一个Data数组的对象。
接下来，我们来看看它的handler，


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:
                result.mTask.onProgressUpdate(result.mData);
                break;
        }
    }
}
@SuppressWarnings({"UnusedDeclaration"})
@MainThread
protected void onProgressUpdate(Progress... values) {
}

可以看到，这里的handler获得的是UI 线程的Looper对象，而它的handleMessage 方法有两种处理结果，收到MESSAGE_POST_PROGRESS时，会执行onProgressUpdate 方法，具体内容也有我们自己实现；而收到MESSAGE_POST_RESULT时，则执行result.mTask.finish(result.mData[0])方法，也就是AsyncTaskResult.mTask.finish()，也就是AsyncTask.this.finish()。

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

@SuppressWarnings({"UnusedDeclaration"})
@MainThread
protected void onPostExecute(Result result) {
}

可以看到，正常情况下，这里会调用onPostExecute(result)方法，而其具体操作也是由我们自己实现，且因为这里是在handler的handleMessage中调用的，所以同样该方法也是运行于UI线程中；但如果我们在任务执行过程中调用了cancel() 方法，由于cancel() 方法会导致isCancelled()返回值为true，于是在finish中便会执行onCancelled 方法而不再执行onPostExecute。最后将mStatus 设为FINISHED。

看完mWorker，我们回到AsyncTask的构造函数来看看mFuture。

public AsyncTask() {  

    ...//mWorker的初始化

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

这里实现了FutureTask的done方法，即任务执行完的操作。这里调用了postResultIfNotInvoked(get())，这里的get()返回的是mWorker的call方法的执行结果，即result。然后作为postResultIfNotInvoked(Result ) 的参数进行处理。

private void postResultIfNotInvoked(Result result) {
    final boolean wasTaskInvoked = mTaskInvoked.get();
    if (!wasTaskInvoked) {
        postResult(result);
    }
}

将mTaskInvoked.get()的返回值赋给wasTaskInvoked ，若为false，则执行postResult(result)，而在前面mWorker的初始化是已经通过mTaskInvoked.set(true)设置为true了，所以postResult不执行。

看完mWorker和mFuture，我们再看看看调用execute方法后会执行的exec.execute(mFuture);，由前面execute方法可知，这里的exec是sDefaultExecutor，所以我们来看看这个sDefaultExecutor具体是怎样的。

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
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) {
        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实例，内部有一个任务队列mTasks。在 execute（Runnable）方法中，将runnable插入到mTasks队尾；然后，若当前mActive为空则调用scheduleNext方法，而scheduleNext则取出mTasks中的队头元素，若不为null便传入THREAD_POOL_EXECUTOR进行执行。而THREAD_POOL_EXECUTOR是一个可以并发执行任务的线程池，具体参数如下。

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;
private static final BlockingQueue<Runnable> sPoolWorkQueue =
            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());
        }
    };

public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

这里需要注意的是，虽然这里用到的是线程池，但是实际上执行的过程却是单线程的，原因是，

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

由于第一个线程进来后，通过(mActive = mTasks.poll()) != null将mActivity置为非null的，导致下一个线程进来后，if (mActive == null)不成立，无法执行scheduleNext()，只能等到当前任务执行完，在finally中才能调用scheduleNext()方法时，才能执行下一个任务。

最后我们通过一张图来回顾下AsyncTask的工作原理：

AsyncTask工作原理