Android 入门 -- AsyncTask

最新推荐文章于 2021-12-03 21:43:33 发布

classTC

最新推荐文章于 2021-12-03 21:43:33 发布

阅读量1.5k

点赞数

分类专栏： Android学习文章标签： android 异步 asynctask 线程

本文链接：https://blog.csdn.net/TTCCAAA/article/details/45204801

版权

Android学习专栏收录该内容

34 篇文章 0 订阅

订阅专栏

异步任务机制（AsyncTask），目的是解决 Android 中不能在主线程中执行耗时操作的问题，由于 Android 系统的特性，如果在主线程中执行耗时操作，将会导致界面卡顿无法及时响应，容易引起 ANR（Application Not Responding）。在 Android 开发中一般会将耗时操作放在子线程中执行，比如网络请求，文件读写操作等，子线程执行完成后再通知主线程更新界面。因此便有了异步任务的概念，主线程在某个时刻发送一个耗时任务交给子线程，然后继续运行主线程的内容，子线程启动后便开始执行耗时任务，执行完成后通知主线程，主线程收到通知后就处理这个通知，没有收到则继续做自己的事。

在Android中实现异步任务机制有很多中方式，比如 Thread，AsyncTask，IntentService，和Handler，本文主要描述 AsyncTask 的实现。

AsyncTask 是一种轻量级的异步任务类，它的实现原理是对 Thread 和 Handler 进行封装，方便开发者在子线程中更新 UI。使用它可以在后台执行耗时任务，并将执行进度和最终结果返回给主线程，可以在主线程中处理执行进度和最终结果，下面开始实现一个简单的异步任务类

AsyncTask 类的定义：

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

三种泛型类型含义如下

Params : 启动任务需要的参数类型
Progress : 后台任务执行的进度类型，一般是 Integer
Result : 后台运行结果的类型

如果不需要传入参数或者没有返回值，则可以用 java.lang.Void 类型代替（注意这里是 Void 类，而不是 void ）

实现一个异步任务类

编写一个自定义的异步任务类时，首先需要继承 AsyncTask 类，然后需要重写一些方法，常用方法描述如下：

onPreExecute() : 在主线程中执行，任务开始前被调用，一般用于为异步任务做准备，比如，在执行异步任务时需要有一个提示框来显示，则可以在这里调用显示提示框的代码
doInBackground(Params… params) : 在后台执行，在onPreExecute()完成后立即执行，用于执行耗时任务，在这里不能直接操作 UI 界面，此方法将接收输入参数和返回运行结果。在执行过程中可以调用publishProgress(Progress… values)来更新进度信息。
onProgressUpdate(Progress… values) : 在主线程中执行，通过在 doInBackground() 中调用 publishProgress(Progress… values)，就会调用此方法，传入的参数即为当前进度值。
onPostExecute(Result result) : 在主线程中执行，后台运行结束后的返回值将作为此方法的参数传入，并开始调用此方法

一个异步任务类至少要重写这两个方法：doInBackground(Params… params)和onPostExecute(Result result)；

使用异步任务类

在使用的时候，类似 Thread 的操作，需要 new 一个该类的实例，并调用其 execute(Params…params) 方法，其中的参数将会传递给 doInBackground(Params…params) 方法

使用时需要注意一下几点：

异步任务类的实例必须在主线程中创建。
execute(Params… params) 方法必须在主线程中调用。
不能在doInBackground(Params… params)中更改UI组件的信息。
一个异步任务的实例只能执行一次，如果执行第二次将会抛出异常。

实例代码

下面是对异步任务类的一个简单实现，需求是实现一个异步下载图片并显示下载进度和将下载的图片显示到界面上的功能，具体代码如下

添加权限

要下载图片，首先需要添加网络访问的权限

<uses-permission android:name="android.permission.INTERNET"/>

界面布局

根据需求，布局界面需要有一个 ImageView 显示图片，并且需要一个 ProgressBar 显示下载进度，最后需要一个 Button 启动异步任务，于是布局界面代码如下

activity_asynctask.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center_horizontal"
    android:orientation="vertical"
    tools:context=".AsyncTaskActivity">

    <ImageView
        android:id="@+id/iv_image"
        android:layout_width="100dp"
        android:layout_height="100dp"
        android:layout_marginTop="16dp"
        android:background="#444444"
        android:contentDescription="@string/app_name"/>

    <TextView
        android:id="@+id/tv_progress_value"
        android:layout_gravity="right"
        android:layout_marginRight="16dp"
        android:layout_marginTop="16dp"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="12sp"
        android:text="0%"/>

    <ProgressBar
        android:layout_marginRight="16dp"
        android:layout_marginLeft="16dp"
        style="?android:attr/progressBarStyleHorizontal"
        android:id="@+id/pb_download_progress"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"/>

    <Button
        android:layout_marginTop="16dp"
        android:id="@+id/bt_download"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="点击下载"/>

</LinearLayout>

编写自定义异步任务类

如前面所述，要实现一个自定义的异步任务，需要继承 AsyncTask 类，并且实现一些方法，具体代码如下：

 /**
     * 三个参数分别指定了三个重写方法传入的参数,如果没有则使用 Void
     * doInBackground(String... params)    ---- String,返回值将作为 onPostExecute() 的参数
     * onProgressUpdate(Integer... values) ---- Integer
     * onPostExecute(byte[] bytes)         ---- byte[]
     */
    class DownloadTask extends AsyncTask<String, Integer, byte[]> {

        /**
         * 在 UI 线程中执行,任务执行前调用
         */
        @Override
        protected void onPreExecute() {
            super.onPreExecute();
        }

        /**
         * 在线程池中执行,用于执行异步任务,这里执行了一个下载过程
         */
        @Override
        protected byte[] doInBackground(String... params) {

            //执行下载,传入的第一个参数是 url
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            try {
                URL mUrl = new URL(params[0]);
                HttpURLConnection conn = (HttpURLConnection) mUrl.openConnection();

                conn.setDoInput(true);
                conn.connect();

                int totalSize = conn.getContentLength();//获取连接的数据总量
                int readSize = 0;

                int len;

                InputStream is = conn.getInputStream();
                byte[] data = new byte[1024];
                while ((len = is.read(data)) != -1) {
                    readSize += len;
                    int progressValue = (int) ((readSize / (float) totalSize) * 100);

                    publishProgress(progressValue);//更新进度
                    bos.write(data, 0, len);
                    Thread.sleep(100);
                }
                is.close();
                bos.close();
                conn.disconnect();

            } catch (Exception e) {
                e.printStackTrace();
            }
            return bos.toByteArray();
        }

        /**
         * 在 UI 线程中执行,当后台任务的执行进度发生改变时被调用,更新进度
         */
        @Override
        protected void onProgressUpdate(Integer... values) {
            super.onProgressUpdate(values);
            progressBar.setProgress(values[0]);
            tvProgressValue.setText(values[0] + "%");
        }

        /**
         * 在 UI 线程中执行,异步任务执行完成后调用
         */
        @Override
        protected void onPostExecute(byte[] bytes) {
            super.onPostExecute(bytes);
            //填充 ImageView
            ivImage.setImageBitmap(BitmapFactory.decodeByteArray(bytes, 0, bytes.length));
            btDownload.setEnabled(true);
        }
    }

可以看到，这里主要的逻辑是在 doInBackground() 中，执行了一个网络下载的过程，并使用publishProgress() 方法来更新下载进度，最后将下载的结果 byte[] 传给 onPostExecute() 用于显示在 ImageView 中。

使用异步任务类

使用就比较简单了，如下：

 btDownload.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                btDownload.setEnabled(false);
                new DownloadTask().execute(IMAGE_URL);//传入图片下载链接,开始执行异步任务
            }
        });

到此，一个完整的使用异步任务的过程就完成了，下面是运行效果：
这里写图片描述

下面详细介绍一下AsyncTask的执行原理。
先看一下AsyncTask的大纲视图：
这里写图片描述
我们可以看到关键几个步骤的方法都在其中，doInBackground(Params… params)是一个抽象方法，我们继承AsyncTask时必须覆写此方法；onPreExecute()、onProgressUpdate(Progress… values)、onPostExecute(Result result)、onCancelled()这几个方法体都是空的，我们需要的时候可以选择性的覆写它们；publishProgress(Progress… values)是final修饰的，不能覆写，只能去调用，我们一般会在doInBackground(Params… params)中调用此方法；另外，我们可以看到有一个Status的枚举类和getStatus()方法，Status枚举类代码段如下：

        //初始状态  
    private volatile Status mStatus = Status.PENDING;  

    public enum Status {  
        /** 
         * Indicates that the task has not been executed yet. 
         */  
        PENDING,  
        /** 
         * Indicates that the task is running. 
         */  
        RUNNING,  
        /** 
         * Indicates that {@link AsyncTask#onPostExecute} has finished. 
         */  
        FINISHED,  
    }  

/** 
     * Returns the current status of this task. 
     * 
     * @return The current status. 
     */  
    public final Status getStatus() {  
        return mStatus;  
    }

可以看到，AsyncTask的初始状态为PENDING，代表待定状态，RUNNING代表执行状态，FINISHED代表结束状态，这几种状态在AsyncTask一次生命周期内的很多地方被使用，非常重要。
介绍完大纲视图相关内容之后，接下来，我们会从execute(Params… params)作为入口，重点分析一下AsyncTask的执行流程，我们来看一下execute(Params… params)方法的代码段：

public final AsyncTask<Params, Progress, Result> execute(Params... params) {  
        if (mStatus != Status.PENDING) {  
            switch (mStatus) {  
                case RUNNING:  
                    //如果该任务正在被执行则抛出异常  
                    //值得一提的是,在调用cancel取消任务后,状态仍未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)");  
            }  
        }  

        //改变状态为RUNNING  
        mStatus = Status.RUNNING;  

        //调用onPreExecute方法  
        onPreExecute();  

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

        return this;  
    }

代码中涉及到三个陌生的变量：mWorker、sExecutor、mFuture，我们也会看一下他们的庐山真面目：
关于sExecutor，它是java.util.concurrent.ThreadPoolExecutor的实例，用于管理线程的执行。代码如下：

private static final int CORE_POOL_SIZE = 5;  
   private static final int MAXIMUM_POOL_SIZE = 128;  
   private static final int KEEP_ALIVE = 10;  

//新建一个队列用来存放线程  
   private static final BlockingQueue<Runnable> sWorkQueue =  
           new LinkedBlockingQueue<Runnable>(10);  
//新建一个线程工厂  
   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 ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,  
           MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue, sThreadFactory);

mWorker实际上是AsyncTask的一个的抽象内部类的实现对象实例，它实现了Callable接口中的call()方法，代码如下：

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

而mFuture实际上是java.util.concurrent.FutureTask的实例，下面是它的FutureTask类的相关信息：

/** 
 * A cancellable asynchronous computation. 
 * ... 
 */  
public class FutureTask<V> implements RunnableFuture<V> {

public interface RunnableFuture<V> extends Runnable, Future<V> {  
    /** 
     * Sets this Future to the result of its computation 
     * unless it has been cancelled. 
     */  
    void run();  
}

可以看到FutureTask是一个可以中途取消的用于异步计算的类。

下面是mWorker和mFuture实例在AsyncTask中的体现：

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

public AsyncTask() {  
       mWorker = new WorkerRunnable<Params, Result>() {  
           //call方法被调用后,将设置优先级为后台级别,然后调用AsyncTask的doInBackground方法  
        public Result call() throws Exception {  
               Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);  
               return doInBackground(mParams);  
           }  
       };  

    //在mFuture实例中,将会调用mWorker做后台任务,完成后会调用done方法  
       mFuture = new FutureTask<Result>(mWorker) {  
           @Override  
           protected void done() {  
               Message message;  
               Result result = null;  

               try {  
                   result = 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) {  
                //发送取消任务的消息  
                   message = sHandler.obtainMessage(MESSAGE_POST_CANCEL,  
                           new AsyncTaskResult<Result>(AsyncTask.this, (Result[]) null));  
                   message.sendToTarget();  
                   return;  
               } catch (Throwable t) {  
                   throw new RuntimeException("An error occured while executing "  
                           + "doInBackground()", t);  
               }  

            //发送显示结果的消息  
               message = sHandler.obtainMessage(MESSAGE_POST_RESULT,  
                       new AsyncTaskResult<Result>(AsyncTask.this, result));  
               message.sendToTarget();  
           }  
       };  
   }

我们看到上面的代码中，mFuture实例对象的done()方法中，如果捕捉到了CancellationException类型的异常，则发送一条“MESSAGE_POST_CANCEL”的消息；如果顺利执行，则发送一条“MESSAGE_POST_RESULT”的消息，而消息都与一个sHandler对象关联。这个sHandler实例实际上是AsyncTask内部类InternalHandler的实例，而InternalHandler正是继承了Handler，下面我们来分析一下它的代码：

private static final int MESSAGE_POST_RESULT = 0x1; //显示结果  
   private static final int MESSAGE_POST_PROGRESS = 0x2;    //更新进度  
   private static final int MESSAGE_POST_CANCEL = 0x3;  //取消任务  

   private static final InternalHandler sHandler = new 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  
                //调用AsyncTask.finish方法  
                   result.mTask.finish(result.mData[0]);  
                   break;  
               case MESSAGE_POST_PROGRESS:  
                   //调用AsyncTask.onProgressUpdate方法  
                result.mTask.onProgressUpdate(result.mData);  
                   break;  
               case MESSAGE_POST_CANCEL:  
                //调用AsyncTask.onCancelled方法  
                   result.mTask.onCancelled();  
                   break;  
           }  
       }  
   }

我们看到，在处理消息时，遇到“MESSAGE_POST_RESULT”时，它会调用AsyncTask中的finish()方法，我们来看一下finish()方法的定义：

private void finish(Result result) {  
        if (isCancelled()) result = null;  
        onPostExecute(result);  //调用onPostExecute显示结果  
        mStatus = Status.FINISHED;  //改变状态为FINISHED  
    }

原来finish()方法是负责调用onPostExecute(Result result)方法显示结果并改变任务状态的啊。
另外，在mFuture对象的done()方法里，构建一个消息时，这个消息包含了一个AsyncTaskResult类型的对象，然后在sHandler实例对象的handleMessage(Message msg)方法里，使用下面这种方式取得消息中附带的对象：

AsyncTaskResult result = (AsyncTaskResult) msg.obj;

这个AsyncTaskResult究竟是什么呢，它又包含什么内容呢？其实它也是AsyncTask的一个内部类，是用来包装执行结果的一个类，让我们来看一下它的代码结构：

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

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

看以看到这个AsyncTaskResult封装了一个AsyncTask的实例和某种类型的数据集，我们再来看一下构建消息时的代码：

//发送取消任务的消息  
message = sHandler.obtainMessage(MESSAGE_POST_CANCEL,  
        new AsyncTaskResult<Result>(AsyncTask.this, (Result[]) null));  
message.sendToTarget();

//发送显示结果的消息  
message = sHandler.obtainMessage(MESSAGE_POST_RESULT,  
         new AsyncTaskResult<Result>(AsyncTask.this, result));  
message.sendToTarget();

在处理消息时是如何使用这个对象呢，我们再来看一下：

result.mTask.finish(result.mData[0]);

result.mTask.onProgressUpdate(result.mData);

概括来说，当我们调用execute(Params… params)方法后，execute方法会调用onPreExecute()方法，然后由ThreadPoolExecutor实例sExecutor执行一个FutureTask任务，这个过程中doInBackground(Params… params)将被调用，如果被开发者覆写的doInBackground(Params… params)方法中调用了publishProgress(Progress… values)方法，则通过InternalHandler实例sHandler发送一条MESSAGE_POST_PROGRESS消息，更新进度，sHandler处理消息时onProgressUpdate(Progress… values)方法将被调用；如果遇到异常，则发送一条MESSAGE_POST_CANCEL的消息，取消任务，sHandler处理消息时onCancelled()方法将被调用；如果执行成功，则发送一条MESSAGE_POST_RESULT的消息，显示结果，sHandler处理消息时onPostExecute(Result result)方法被调用。
经过上面的介绍，相信朋友们都已经认识到AsyncTask的本质了，它对Thread+Handler的良好封装，减少了开发者处理问题的复杂度，提高了开发效率，希望朋友们能多多体会一下。