Android AsyncTask类使用总结

深碍√TFBOYSˉ_ 2022-05-27 06:38 172阅读 0赞

**1、概述**

在Android程序开始运行的时候会单独启动一个进程，默认情况下所有这个程序操作都在这个进程中进行。一个Android程序默认情况下只有一个进程，但一个进程中可以有多个线程。

在这些线程中，有一个线程叫做UI线程（也叫Main Thread），除了UI线程外的线程都叫子线程（Worker Thread）。UI线程主要负责控制UI界面的显示、更新、交互等。因此，UI线程中的操作延迟越短越好（流畅）。把一些耗时的操作（网络请求、数据库操作、逻辑计算等）放到单独的线程，可以避免主线程阻塞。

在Android中我们可以通过Thread+Handler实现多线程通信，一种经典的使用场景是：在新线程中进行耗时操作，当任务完成后通过Handler向主线程发送Message，这样主线程的Handler在收到该Message之后就可以进行更新UI的操作。上述场景中需要分别在Thread和Handler中编写代码逻辑，为了使得代码更加统一，我们可以使用AsyncTask类。

AsyncTask是Android提供的一个助手类，它对Thread和Handler进行了封装，方便我们使用。Android之所以提供AsyncTask这个类，就是为了方便我们在后台线程中执行操作，然后将结果发送给主线程，从而在主线程中进行UI更新等操作。在使用AsyncTask时，我们无需关注Thread和Handler，AsyncTask内部会对其进行管理，这样我们就只需要关注于我们的业务逻辑即可。

**2、方法介绍**

AsyncTask有四个重要的回调方法，分别是：onPreExecute、doInBackground, onProgressUpdate 和 onPostExecute。这四个方法会在AsyncTask的不同时期进行自动调用，我们只需要实现这几个方法的内部逻辑即可。这四个方法的一些参数和返回值都是基于泛型的，而且泛型的类型还不一样，所以在AsyncTask的使用中会遇到三种泛型参数：Params, Progress 和 Result，如下图所示：

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

1）Params表示用于AsyncTask执行任务的参数的类型，**传参**

2）Progress表示在后台线程处理的过程中，可以阶段性地发布结果的数据类型，**进度条**

3）Result表示任务全部完成后所返回的数据类型，**返回值**

**我们通过调用AsyncTask的execute()方法传入参数并执行任务，然后AsyncTask会依次调用以下四个方法：**

1）onPreExecute

@Override
    protected void onPreExecute() {

该方法是运行在主线程中的。在AsyncTask执行了execute()方法后就会在UI线程上执行onPreExecute()方法，该方法在task真正执行前运行，我们通常可以在该方法中显示一个进度条，从而告知用户后台任务即将开始。

2）doInBackground

@Override
    protected Integer doInBackground(Integer... params) {

该方法是运行在单独的工作线程中的，而不是运行在主线程中。doInBackground会在onPreExecute()方法执行完成后立即执行，该方法用于在工作线程中执行耗时任务，我们可以在该方法中编写我们需要在后台线程中运行的逻辑代码，由于是运行在工作线程中，所以该方法不会阻塞UI线程。该方法接收Params泛型参数，参数params是Params类型的不定长数组，该方法的返回值是Result泛型，由于doInBackgroud是抽象方法，我们在使用AsyncTask时必须重写该方法。在doInBackground中执行的任务可能要分解为好多步骤，每完成一步我们就可以通过调用AsyncTask的publishProgress(Progress…)将阶段性的处理结果发布出去，阶段性处理结果是Progress泛型类型。当调用了publishProgress方法后，处理结果会被传递到UI线程中，并在UI线程中回调onProgressUpdate方法，下面会详细介绍。根据我们的具体需要，我们可以在doInBackground中不调用publishProgress方法，当然也可以在该方法中多次调用publishProgress方法。doInBackgroud方法的返回值表示后台线程完成任务之后的结果。

3）onProgressUpdate

@Override
    protected void onProgressUpdate(Integer... values) {

该方法是在主线程上被调用的，且传入的参数是Progress泛型定义的不定长数组。如果在doInBackground中多次调用了publishProgress方法，那么主线程就会多次回调onProgressUpdate方法。上面我们知道，当我们在doInBackground中调用publishProgress(Progress…)方法后，就会在UI线程上回调onProgressUpdate方法。

4）onPostExecute

@Override
    protected void onPostExecute(Integer result) {

该方法是在主线程中被调用的。当doInBackgroud方法执行完毕后，就表示任务完成了，doInBackgroud方法的返回值就会作为参数在主线程中传入到onPostExecute方法中，这样就可以在主线程中根据任务的执行结果更新UI。

**3、示例**

1）xml布局文件

2）AsyncTask下载类

public class MainActivity extends Activity implements Button.OnClickListener {
    
        TextView textView = null;
        Button btnDownload = null;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            textView = (TextView)findViewById(R.id.textView);
            btnDownload = (Button)findViewById(R.id.btnDownload);
            Log.i("iSpring", "MainActivity -> onCreate, Thread name: " + Thread.currentThread().getName());
        }
    
        @Override
        public void onClick(View v) {
            //要下载的文件地址
            String[] urls = {
                    "http://blog.csdn.net/iispring/article/details/47115879",
                    "http://blog.csdn.net/iispring/article/details/47180325",
                    "http://blog.csdn.net/iispring/article/details/47300819",
                    "http://blog.csdn.net/iispring/article/details/47320407",
                    "http://blog.csdn.net/iispring/article/details/47622705"
            };
    
            DownloadTask downloadTask = new DownloadTask();
            downloadTask.execute(urls);
        }
    
        //public abstract class AsyncTask<Params, Progress, Result>
        //在此例中，Params泛型是String类型，Progress泛型是Object类型，Result泛型是Long类型
        private class DownloadTask extends AsyncTask<String, Object, Long> {
            @Override
            protected void onPreExecute() {
                Log.i("iSpring", "DownloadTask -> onPreExecute, Thread name: " + Thread.currentThread().getName());
                super.onPreExecute();
                btnDownload.setEnabled(false);
                textView.setText("开始下载...");
            }
    
            @Override
            protected Long doInBackground(String... params) {
                Log.i("iSpring", "DownloadTask -> doInBackground, Thread name: " + Thread.currentThread().getName());
                //totalByte表示所有下载的文件的总字节数
                long totalByte = 0;
                //params是一个String数组
                for(String url: params){
                    //遍历Url数组，依次下载对应的文件
                    Object[] result = downloadSingleFile(url);
                    int byteCount = (int)result[0];
                    totalByte += byteCount;
                    //在下载完一个文件之后，我们就把阶段性的处理结果发布出去
                    publishProgress(result);
                    //如果AsyncTask被调用了cancel()方法，那么任务取消，跳出for循环
                    if(isCancelled()){
                        break;
                    }
                }
                //将总共下载的字节数作为结果返回
                return totalByte;
            }
    
            //下载文件后返回一个Object数组：下载文件的字节数以及下载的博客的名字
            private Object[] downloadSingleFile(String str){
                Object[] result = new Object[2];
                int byteCount = 0;
                String blogName = "";
                HttpURLConnection conn = null;
                try{
                    URL url = new URL(str);
                    conn = (HttpURLConnection)url.openConnection();
                    InputStream is = conn.getInputStream();
                    ByteArrayOutputStream baos = new ByteArrayOutputStream();
                    byte[] buf = new byte[1024];
                    int length = -1;
                    while ((length = is.read(buf)) != -1) {
                        baos.write(buf, 0, length);
                        byteCount += length;
                    }
                    String respone = new String(baos.toByteArray(), "utf-8");
                    int startIndex = respone.indexOf("<title>");
                    if(startIndex > 0){
                        startIndex += 7;
                        int endIndex = respone.indexOf("</title>");
                        if(endIndex > startIndex){
                            //解析出博客中的标题
                            blogName = respone.substring(startIndex, endIndex);
                        }
                    }
                }catch(MalformedURLException e){
                    e.printStackTrace();
                }catch(IOException e){
                    e.printStackTrace();
                }finally {
                    if(conn != null){
                        conn.disconnect();
                    }
                }
                result[0] = byteCount;
                result[1] = blogName;
                return result;
            }
    
            @Override
            protected void onProgressUpdate(Object... values) {
                Log.i("iSpring", "DownloadTask -> onProgressUpdate, Thread name: " + Thread.currentThread().getName());
                super.onProgressUpdate(values);
                int byteCount = (int)values[0];
                String blogName = (String)values[1];
                String text = textView.getText().toString();
                text += "\n博客《" + blogName + "》下载完成，共" + byteCount + "字节";
                textView.setText(text);
            }
    
            @Override
            protected void onPostExecute(Long aLong) {
                Log.i("iSpring", "DownloadTask -> onPostExecute, Thread name: " + Thread.currentThread().getName());
                super.onPostExecute(aLong);
                String text = textView.getText().toString();
                text += "\n全部下载完成，总共下载了" + aLong + "个字节";
                textView.setText(text);
                btnDownload.setEnabled(true);
            }
    
            @Override
            protected void onCancelled() {
                Log.i("iSpring", "DownloadTask -> onCancelled, Thread name: " + Thread.currentThread().getName());
                super.onCancelled();
                textView.setText("取消下载");
                btnDownload.setEnabled(true);
            }
        }
    }

3）点击下载按钮

![70][]

控制台输出如下所示：

![70 1][]

下面对以上代码进行一下说明。

1.  我们在MainActivity中定义了内部类DownloadTask，DownloadTask继承自AsyncTask，在该例中，Params泛型是String类型，Progress泛型是Object类型，Result泛型是Long类型。
2.  我们定义了一个Url字符串数组，将该数组传递给AsyncTask的execute方法，用于异步执行task。
3.  在执行了`downloadTask.execute(urls)`之后，AsyncTask会自动回调onPreExecute方法，在该方法中我们将textView设置为“开始下载…”几个字，告知用户即将执行下载操作。通过控制台输出我们也可以看出该方法是在主线程中执行的。
4.  在执行了onPreExecute方法之后，AsyncTask会回调doInBackground方法，该方法中的输入参数是String类型的不定长数组，此处的String就对应着Params泛型类型，我们在该方法中遍历Url数组，依次下载对应的文件，当我们下载完一个文件，就相当于我们阶段性地完成了一部分任务，我们就通过调用publishProgress方法将阶段性处理结果发布出去。在此例中我们将阶段性的处理结果定义为Object类型，即Progress泛型类型。通过控制台输出我们可以看出doInBackground方法是运行在新的工作线程”AsyncTask \#1”中的，AsyncTask的工作线程都是以”AsyncTask \#”然后加上数字作为名字。当所有文件下载完成后，我们就可以通过totalSize返回所有下载的字节数，返回值类型为Long，对应着AsyncTask中的Result泛型类型。
5.  在doInBackground方法中，每当下载完一个文件，我们就会调用publishProgress方法发布阶段性结果，之后AsyncTask会回调onProgressUpdate方法，在此例中，onProgressUpdate的参数为Object类型，对应着AsyncTask中的Progress泛型类型。通过控制台输出我们可以发现，该方法是在主线程中调用的，在该方法中我们会通过textView更新UI，告知用户哪个文件下载完成了，这样用户体验相对友好。
6.  在整个doInBackground方法执行完毕后，AsyncTask就会回调onPostExecute方法，在该方法中我们再次通过textView更新UI告知用户全部下载任务完成了。
7.  在通过execute方法执行了异步任务之后，可以通过AsyncTask的cancel方法取消任务，取消任务后AsyncTask会回调onCancelled方法，这样不会再调用onPostExecute方法。

在使用Android的过程中，有以下几点需要注意：

*  AsyncTask的实例必须在主线程中创建。
 *  AsyncTask的execute方法必须在主线程中调用。
 *  onPreExecute()、onPostExecute(Result),、doInBackground(Params…) 和 onProgressUpdate(Progress…)这四个方法都是回调方法，Android会自动调用，我们不应自己调用。
 *  对于一个AsyncTack的实例，只能执行一次execute方法，在该实例上第二次执行execute方法时就会抛出异常。

通过上面的示例，大家应该熟悉了AsyncTask的使用流程。我们上面提到，对于某个AsyncTask实例，只能执行一次execute方法，如果我们想并行地执行多个任务怎么办呢？我们可以考虑实例化多个AsyncTask实例，然后分别调用各个实例的execute方法，为了探究效果，我们将代码更改如下所示：

public void onClick(View v) {
            //要下载的文件地址
            String[] urls = {
                    "http://blog.csdn.net/iispring/article/details/47115879",
                    "http://blog.csdn.net/iispring/article/details/47180325",
                    "http://blog.csdn.net/iispring/article/details/47300819",
                    "http://blog.csdn.net/iispring/article/details/47320407",
                    "http://blog.csdn.net/iispring/article/details/47622705"
            };
    
            DownloadTask downloadTask1 = new DownloadTask();
            downloadTask1.execute(urls);
    
            DownloadTask downloadTask2 = new DownloadTask();
            downloadTask2.execute(urls);
    }

在单击了按钮之后，我们实例化了两个DownloadTask，并分别执行其execute方法，运行后界面如下所示：

![这里写图片描述][20160206175045997]

控制台输出如下所示：

![70 2][]

我们观察一下控制台的输出结果，可以发现对于downloadTask1，doInBackground方法是运行在线程“AsyncTask \#1”中的；对于downloadTask2，doInBackground方法是运行在线程”AsyncTask \#2”中的，此时我们可能会认为太好了，两个AsyncTask实例分别在不同的线程中运行，实现了并行处理。此处真的是并行运行的吗？

我们自己观察控制台输出就可以发现，downloadTask1的doInBackground方法执行后，下载了五个文件，并五次触发了onProgressUpdate，在这之后才执行downloadTask2的doInBackground方法。我们对比上面的GIF图也可以发现，在downloadTask1按照顺序下载完五篇文章之后，downloadTask2才开始按照顺序下载五篇文章。综上所述，我们可以知道，默认情况下如果创建了AsyncTask创建了多个实例，并同时执行实例的各个execute方法，那么这些实例的execute方法并不是并行执行的，是串行执行的，即在第一个实例的doInBackground完成任务后，第二个实例的doInBackgroud方法才会开始执行，然后再执行第三个实例的doInBackground方法… 那么你可能会问，不对啊，上面downloadTask1是运行在”AsyncTask \#1”线程中的，downloadTask2是运行在”AsyncTask \#2”线程中的，这明明是两个线程啊！其实AsyncTask为downloadTask1开辟了名为”AsyncTask \#1”的工作线程，在其完成了任务之后可能就销毁了，然后AsyncTask又为downloadTask2开辟了名为”AsyncTask \#2”的工作线程。

AsyncTask在最早的版本中用一个单一的后台线程串行执行多个AsyncTask实例的任务，从Android 1.6（DONUT）开始，AsyncTask用线程池并行执行异步任务，但是从Android 3.0（HONEYCOMB）开始为了避免并行执行导致的常见错误，AsyncTask又开始默认用单线程作为工作线程处理多个任务。

从Android 3.0开始AsyncTask增加了executeOnExecutor方法，用该方法可以让AsyncTask并行处理任务，该方法的方法签名如下所示：

public final AsyncTask<Params, Progress, Result> executeOnExecutor (Executor exec, Params... params)

第一个参数表示exec是一个Executor对象，为了让AsyncTask并行处理任务，通常情况下我们此处传入`AsyncTask.THREAD_POOL_EXECUTOR`即可，`AsyncTask.THREAD_POOL_EXECUTOR`是AsyncTask中内置的一个线程池对象，当然我们也可以传入我们自己实例化的线程池对象。第二个参数params表示的是要执行的任务的参数。

通过executeOnExecutor方法并行执行任务的示例代码如下所示：

public void onClick(View v) {
            if(Build.VERSION.SDK_INT >= 11){
                String[] urls = {
                        "http://blog.csdn.net/iispring/article/details/47115879",
                        "http://blog.csdn.net/iispring/article/details/47180325",
                        "http://blog.csdn.net/iispring/article/details/47300819",
                        "http://blog.csdn.net/iispring/article/details/47320407",
                        "http://blog.csdn.net/iispring/article/details/47622705"
                };
    
                DownloadTask downloadTask1 = new DownloadTask();
                downloadTask1.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, urls);
    
                DownloadTask downloadTask2 = new DownloadTask();
                downloadTask2.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, urls);
            }
    }

我们实例化了两个DownloadTask的实例，然后执行了这两个实例的executeOnExecutor方法，并将`AsyncTask.THREAD_POOL_EXECUTOR`作为Executor传入，二者都接收同样的Url数组作为任务执行的参数。

点击下载按钮后，运行完的界面如下所示：

![这里写图片描述][20160206211208358]

控制台输出如下所示：

![70 3][]

通过控制台的输出结果我们可以看到，在downloadTask1执行了doInBackground方法后，downloadTask2也立即执行了doInBackground方法。并且通过程序运行完的UI界面可以看到在一个DownloadTask实例下载了一篇文章之后，另一个DownloadTask实例也立即下载了一篇文章，两个DownloadTask实例交叉按顺序下载文件，可以看出这两个AsyncTask的实例是并行执行的。

如果大家想了解AsyncTask的工作原理，可参见另一篇博文[《源码解析Android中AsyncTask的工作原理》][Android_AsyncTask] 。

完！！！

[70]: /images/20220527/c0eb9811bf4b4b0a9d624e676029a9fb.png
[70 1]: /images/20220527/08ffef911f764d9a8014a5fecbb7b7ca.png
[20160206175045997]: /images/20220527/d47998b4901840cbb8258e483df1197f.png
[70 2]: /images/20220527/9a1cb4dfdf624730ad974d8aa6c1874e.png
[20160206211208358]: /images/20220527/1c731b3fb9ac459e8cfd42a36b86a48c.png
[70 3]: /images/20220527/6ac61b64b17d410f8f9e8780af46132a.png
[Android_AsyncTask]: http://blog.csdn.net/iispring/article/details/50670388