AsyncTask简单介绍

大家应该都知道AsyncTask这个类，也应该或多或少都接触过这个类，它可以帮我们完成一次性异步任务并把结果返回到主线程，而且在后台运行过程中可以不断的在主线程更新UI，所以其实如果使用它确实可以帮我替代自己手动new Thread + Handler，虽然平时好像主流项目中已经很少用使用它了取而代之的是更加火爆的RxJava。

而且我也很少会用到AsyncTask，但这毕竟是Android提供给我们的原生异步工具，最基本的使用还是需要掌握的，而且2017年我也希望可以克服自己对阅读源码的恐惧和不自信，所以就打算拿它来开第一刀，那么接下来我们先来说说他的使用和需要用到的方法吧。

AsyncTask基本使用和常用方法介绍

1.官方Demo

//  这是AsyncTask官方文档给出的使用示例
//  AsyncTask本身是一个抽象类，我们需要自己实现里面的抽象方法和我们需要用到的方法
//  AsyncTask<URL, Integer, Long>这里有三个泛型，分别表示我们执行时需要传递的参数，
//    更新进度传递数据的类型和返回结果的类型
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]);
             //  这是AsyncTask提供给我们的方法，用来通知AsyncTask调用onProgressUpdate
             publishProgress((int) ((i / (float) count) * 100));
             //  Escape early if cancel() is called
             //  通过判断任务是否被取消从而退出循环结束任务
             if (isCancelled()) break;
         }
         return totalSize;
     }
     //  该方法在UI线程运行，用来不断的更新UI
     protected void onProgressUpdate(Integer... progress) {
         setProgressPercent(progress[0]);
     }
     //  该方法在UI线程运行，doInBackground会在执行结束把任务结果通过这个方法传递给主线程
     protected void onPostExecute(Long result) {
         showDialog("Downloaded " + result + " bytes");
     }
 }
//  通过调用AsyncTask的execute来执行这个异步任务
new DownloadFilesTask().execute(url1, url2, url3);

看完这个Demo和我写的一些注释，我想我们应该可以顺利的定义一个自己的AsyncTask了。

2.AsyncTask类介绍

我们先来看看AsyncTask的类定义：

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

这里我们一目了然的看到了AsyncTask是一个抽象类，我们需要自己实现自己的AsyncTask来使用，而这里我们看到了三个泛型，他们代表的意义分别为：
①Params，执行时任务发送到任务的参数的类型，在调用execute(Params)时传递过去，在耗时操作的方法doInBackground(Params)中去使用。

②Progress，在后台做耗时操作期间更新进度时参数的类型，在publishProgress(Progress)，onProgressUpdate(Progress)这两个方法中使用。

③Result，耗时操作的返回结果的类型，在onPostExecute(Result)中使用。

3.AsyncTask常用方法介绍

// 自定义AsyncTask会使用的方法
①onPreExecute()：在UI线程被调用，用于在执行耗时操作前的一些初始化工作，doInBackground()前被调用，比如初始化进度条(随便举例的)。

②doInBackground(Params... params)：抽象方法，在后台线程运行，自定义AsyncTask必须要重写的一个方法，可以把某些耗时操作写到这里。

③onProgressUpdate(Progress... values)：在UI线程运行，用来更新UI数据，比如更新进度条显示，更新其他控件显示。

④publishProgress(Progress... values)：在后台线程运行，在doInBackground()方法中被调用，通过内部Handler通知onProgressUpdate()更新UI。

⑤onPostExecute(Result result)：在UI线程被调用，用于在doInBackground()执行完拿到结果并传递给主线程去做相应的处理。

⑥onCancelled()&onCancelled(Result result):在UI线程被调用，任务被取消后会调用这两个方法。

⑦isCancelled():判断任务是否被取消，可以在doInBackground()的循环中调用，从而结束任务(只是举例)。

//  自定义的AsyncTask的实例会调用的方法

⑧execute(Params... params)：在UI线程调用，开始执行任务。

⑨executeOnExecutor(Executor exec, Params... params)：开始执行任务，并使用指定的线程池。

⑩cancel(boolean mayInterruptIfRunning)：在UI线程被调用，取消当前任务，参数意义为是否可以中断当前任务运行。

AsyncTask执行流程和源码阅读记录

1.执行流程(用上面的数值表示任务名称)：实例化AsyncTask后先调用⑧or⑨，然后调用①，紧接着立马调用②，如果在②中调用④，则会执行③，当然也会在执行②的过程中调用⑦去判断任务是否被取消了，从而结束任务，最后执行完②之后会执行⑤，从而拿到返回的结果，当然如果任务被取消了不会执行⑤，而是回调⑥。

2.源码中的体现：
我们execute(Params... params)执行任务之后，它会自己调用executeOnExecutor(Executor exec, Params... params)这个方法，而这里它传入了一个默认的线程池，而这个线程池是一个顺序执行的线程池，但其实它并不是一直都是顺序执行的，Android1.6开始是并行执行，之前是顺序执行，而3.0之后又改为了顺序执行，所以这也是为什么如果我同时执行很多个AsyncTask，会感觉等待的时间很长，就是因为它会一个一个任务的处理，而不是并发处理。

execute(Params... params).png

executeOnExecutor(Executor exec, Params... params).png

Paste_Image.png

private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
    Params[] mParams;
}
//  WorkerRunnable重写的call里面的逻辑
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;
}

    我们还应该注意到一个细节就是WorkerRunnable重写的call方法里面的finally最后去调用了postResult(result)，看名字就是知道是传递结果的一个方法，下面我们来看看这个方法，如下图，我们看到它通过getHandler()这个静态方法(因为方法是斜着的你也注意到了吧？)拿到了自定义的Handler的静态内部类，通过Message类的obtainMessage去创建了Message，what为MESSAGE_POST_RESULT，传递的参数为new AsyncTaskResult<Result>(this, result)(接下来我们会介绍到它的)。

postResult(Result result).png

Paste_Image.png

//  这就是AsyncTaskResult，果然mTask就是AsyncTask 类型，而mData[0]就是我们需要的结果
private static class AsyncTaskResult<Data> {
    final AsyncTask mTask;
    final Data[] mData; 
    AsyncTaskResult(AsyncTask task, Data... data) {
        mTask = task;
        mData = data;
    }
}

下面我们应该接下去去看看刚才说到的finish(Result result)这个方法，如下图，如果不是被取消就会把结果传递到onPostExecute(Result result)里面从而完成AsyncTask的正常流程去，如果被取消了就会执行取消任务的相关回调，这里就不一一赘述了。

finish(Result result).png

接下来我们去看看一下我们没说的到源码一开始的时候我们说了3.0之后AsyncTask又被Android改成了顺序执行任务，而我们一开始使用的就是AsyncTask提供给我们的默认的线程池，而其实AsyncTask也提供了一个它自定义的线程池可以并发AsyncTask，下面是代码：

//  AsyncTask的默认的线程池
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
//  SERIAL_EXECUTOR实现是new出来的一个自定义类类
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
//  AsyncTask自带的自定义的线程池
public static final Executor THREAD_POOL_EXECUTOR;
//  线程池的参数，定义了核心线程数，最大线程数，线程工厂，空闲线程活跃时间，任务等待队列
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);
//  利用静态代码块创建自定义线程池
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;
}

//  如果想要并发完成任务调用executeOnExecutor(Executor exec, Params... params)就可以了
//  这样就实现了这三个任务并发执行了
new DownloadFilesTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "url");
new DownloadFilesTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "url");
new DownloadFilesTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "url");

    AsyncTask中默认的是sDefaultExecutor，那我们再来看看它的代码，如下图，它直接实现自Executor，两个参数一个是双端队列(我也是Google之后才知道的)和一个Runnable，还记得这个默认的线程池的excute是什么被调用的么？是在doInBackground(Params... params)最后几步调用的，然后把mFuture作为Runnable传递过去，默认的线程池的excute做了两件事，一个是向双端队列尾部插入一条数据，然后判断另一个变量mActive是否为空，那么一上来肯定为空，会执行scheduleNext()方法，移除并拿到双端队列的一个数据赋值给mActive，然后再调用自定义的线程池执行mActive，虽然看上去它把任务又交给了自定义的线程池，好像可以并发执行似得，但是其实仔细一看它是r.run()执行完了才会执行finally，然后在执行下一个任务的，所以就成了顺序执行。

mWorker.mParams = params;
exec.execute(mFuture);

AsyncTask默认使用线程池.png

publishProgress(Progress... values).png

AsyncTask注意点总结

1.Andorid3.0之后AsyncTask顺序执行任务，所以如果有多个任务又想同时并发执行的话可以调用下面的代码来实现该功能。

new xxxAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, 若干参数);
new xxxAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, 若干参数);
new xxxAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, 若干参数);
......

2.一个AsyncTask只能执行一次。

3.任务实例必须在UI线程上创建。

4.execute（Params ...）必须在UI线程上调用。

5.不要手动调用onPreExecute()，onPostExecute()，doInBackground()，onProgressUpdate()。
6.多AsyncTask执行顺序，如图(字确实丑，见谅)：

多AsyncTask执行顺序.png

我希望可以站在初学者&自学者的角度把Android中的知识点很清楚的介绍给大家，希望大家喜欢。 如果有错误希望指出来，有问题或者没看懂，都可以来问我的