异步AsyncTask的使用与原理分析

在Android中，我们更新UI的操作必须要在主线程（UI线程）中进行，而下载图片、文件这种操作必须要在子线程中进行，Android为我们提供了Handler机制，实现了子线程与主线程之间的通信。通常做法就是先new出一个子线程Thread，在子线程中完成下载操作后，通过handler发送一条Message给主线程，主线程收到消息后，就可以进行UI的更新工作了，如下：

Handler mHadler = new Handler(){
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        if(msg.what == 1){
            Bitmap bitmap = (Bitmap) msg.obj;
            //更新UI...
        }
    }
};
 
private void download(){
    new Thread(new Runnable() {
        @Override
        public void run() {
            // 这里进行下载操作...获得了图片的bitmap
            //下载完后才，向主线程发送Message
            Message msg = Message.<em>obtain</em>();
            msg.obj = bitmap;
            msg.what = 1;//区分哪一个线程发送的消息
            mHadler.sendMessage(msg);
        }
    }).start();

}

可以看到，每次要进行下载工作，我们就得先创建出Thread，然后在主线程中写好handler，为了对这个过程进行封装，Android提供了AsyncTask异步任务，AsyncTask对线程和handler进行了封装，使得我们可以直接在AsyncTask中进行UI的更新操作，就好像是在子线程进行UI更新一样。

1.2 创建AsyncTask子类

AsyncTask是一个抽象类，我们必须写一个子类继承它，在子类中完成具体的业务下载操作。为了对各种情况更好的封装，AsyncTask抽象类指定了三个泛型参数类型，如下：

public abstract class AsyncTask<Params, Progress, Result>

其中，三个泛型类型参数的含义如下：
 
Params：开始异步任务执行时传入的参数类型，即doInBackground()方法中的参数类型；
Progress：异步任务执行过程中，返回下载进度值的类型，即在doInBackground中调用publishProgress()时传入的参数类型；

Result：异步任务执行完成后，返回的结果类型，即doInBackground()方法的返回值类型；

1.3 AsyncTask的回调方法
前面我们说过，AsyncTask对线程和handler进行了封装，那它的封装性体现在哪里呢？其实，AsyncTask的几个回调方法正是这种封装性的体现，使得我们感觉在子线程进行UI更新一样。一个基本的AsyncTask有如下几个回调方法：
（1）onPreExecute()：在执行后台下载操作之前调用，运行在主线程中；

（2）doInBackground()：核心方法，执行后台下载操作的方法，必须实现的一个方法，运行在子线程中；这个方法是执行在子线程中的。在onPreExecute()执行完后，会立即开启这个方法。

（3）onProgressUpdate()：在下载操作doInBackground()中调用publishProgress()时的回调方法，用于更新下载进度，运行在主线程中；

（4）onPostExecute()：后台下载操作完成后调用，运行在主线程中；
因此，AsyncTask的基本生命周期过程为：onPreExecute() --> doInBackground() --> onPostExecute()。其中，onPreExecute()和onPostExecute()分别在下载操作前和下载操作后调用，同时它们是在主线程中进行调用，因此可以在这两个方法中进行UI的更新操作，比如，在onPreExecute()方法中，将下载等待动画显示出来，在onPostExecute()方法中，将下载等待动画进行隐藏。
如果我们想向用户展示文件的下载进度情况，这时，我们可以在doInBackground()下载操作中，调用publishProgress()，将当前进度值传入该方法，而publishProgress()内部会去调用AsyncTask的另一个回调方法：

因此，在需要更新进度值时，AsyncTask的基本生命周期过程为：onPreExecute() --> doInBackground() --> publishProgress() -->onProgressUpdate()--> onPostExecute()。

可以看到，AsyncTask的优秀之处在于几个回调方法的设置上，只有donInBackground()是运行在子线程的，其他三个回调方法都是在主线程中运行，因此，只要在AsyncTask中，就可以实现文件的后台下载、UI的更新操作。

首先实现一个AsyncTask的具体实现类，进行图片的下载，如下：

public class MyAsyncTask extends AsyncTask<string, bitmap="">{
    private ProgressBar mPreogressBar;//进度条
    private ImageView mImageView;//图片显示控件
 
    public MyAsyncTask(ProgressBar pb,ImageView iv){
        mPreogressBar = pb;
        mImageView = iv;
    }
 
    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        mPreogressBar.setVisibility(View.<em>VISIBLE</em>);
    }
 
    @Override
    protected Bitmap doInBackground(String... params) {
        String urlParams = params[0];//拿到execute()传过来的图片url
        Bitmap bitmap = null;
        URLConnection conn = null;
        InputStream is = null;
        try {
            URL url = new URL(urlParams);
            conn = url.openConnection();
            is = conn.getInputStream();
 
            //这里只是为了演示更新进度的功能，实际的进度值需要在从输入流中读取时逐步获取
            for(int i = 0; i < 100; i++){
                publishProgress(i);
                Thread.<em>sleep</em>(50);//为了看清效果，睡眠一段时间
            }
            //将获取到的输入流转成Bitmap
            BufferedInputStream bis = new BufferedInputStream(is);
            bitmap = BitmapFactory.<em>decodeStream</em>(bis);
 
            is.close();
            bis.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return bitmap;
    }
 
    @Override
    protected void onProgressUpdate(Integer... values) {
        super.onProgressUpdate(values);
        mPreogressBar.setProgress(values[0]);
    }
 
    @Override
    protected void onPostExecute(Bitmap bitmap) {
        super.onPostExecute(bitmap);
        mPreogressBar.setVisibility(View.<em>GONE</em>);
        mImageView.setImageBitmap(bitmap);
    }

}

上面doInBackground()中获取进度值时，我们只是为了做一个进度值更新调用的演示，实际项目文件下载中，我们可能会对拿到的输入流进行处理，比如读取输入流将文件保存到本地，在读取输入流的时候，我们就可以获取到已经读取的输入流大小作为进度值了，如下：

//实际项目中如何获取文件大小作为进度值及更新进度值
            int totalSize = conn.getContentLength();//获取文件总大小
            int size = 0;//保存当前下载文件的大小，作为进度值
            int count = 0;
            byte[] buffer = new byte[1024];
            while((count = is.read(buffer)) != -1){
                size += count;//获取已下载的文件大小
                //调用publishProgress更新进度，它内部会回调onProgressUpdate()方法
                publishProgress(size,totalSize);
                Thread.sleep(100);//为了看清效果，睡眠一段时间
            }

在MainActivity中使用：

public class MainActivity extends AppCompatActivity {
    private ImageView mImageView;
    private ProgressBar mProgressBar;

private static String <em>URL </em>= "https://c.hiphotos.baidu.com/baike/s%3D220/sign=86442af5a6c27d1ea1263cc62bd4adaf/42a98226cffc1e17d8f914604890f603738de919.jpg";
    private MyAsyncTask asyncTask;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.<em>image</em>);
 
        mImageView = (ImageView) findViewById(R.id.<em>id_image</em>);
        mProgressBar = (ProgressBar) findViewById(R.id.<em>pb</em>);
 
        asyncTask = new MyAsyncTask(mProgressBar, mImageView);
        asyncTask.execute(<em>URL</em>);//将图片url作为参数传入到doInBackground()中
    }

}

1.4 取消下载任务

我们先来看两个现象。 我们在布局中加一个按钮，点击这个按钮再加载一次图片，布局如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<!--?xml version="1.0" encoding="utf-8"?-->
<relativelayout br="" xmlns:android="https://schemas.android.com/apk/res/android">    android:padding="16dp"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <imageview<br>        android:id="@+id/id_image"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />
    <progressbar<br>        android:id="@+id/pb"
        style="@style/Widget.AppCompat.ProgressBar.Horizontal"
        android:layout_centerInParent="true"
        android:layout_width="match_parent"
        android:layout_height="30dp" />
    <button<br>        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:padding="15dp"
        android:id="@+id/id_btn"
        android:text="加载图片"
        android:textSize="16sp"
        android:layout_alignParentBottom="true"
        android:onClick="loadImage"/>
</button<br></progressbar<br></imageview<br></relativelayout>

因此，在MainActivity中，我们就需要加入loadImage方法，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class MainActivity extends AppCompatActivity {
    private ImageView mImageView;
    private ProgressBar mProgressBar;
    private static String <em>url </em>= "https://c.hiphotos.baidu.com/baike/s%3D220/sign=86442af5a6c27d1ea1263cc62bd4adaf/42a98226cffc1e17d8f914604890f603738de919.jpg";
    private MyAsyncTask asyncTask;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.<em>image</em>);
 
        mImageView = (ImageView) findViewById(R.id.<em>id_image</em>);
        mProgressBar = (ProgressBar) findViewById(R.id.<em>pb</em>);
 
        asyncTask = new MyAsyncTask(mProgressBar, mImageView);
        asyncTask.execute(<em>url</em>);
}
 
    public void loadImage(View v){
        asyncTask.execute(<em>url</em>);
    }
}

现象一：在loadImage()方法中，我们直接再次通过asyncTask.execute()执行加载。看看此时效果如何：

异步AsyncTask的使用与原理分析

onCreate中初始加载完一次图片后，我们点击“加载图片”按钮，此时程序直接崩溃了！这是因为，每一个new出的AsyncTask只能执行一次execute()，如果同一个AsyncTask多次执行execute()执行将会报错。

现象二：我们来修改loadImage()方法，在该方法中，我们在打开自身MainActivity，使得多次初始化的时候进行加载，如下：

1
2
3
4
public void loadImage(View v){
    Intent i = new Intent(this,MainActivity.class);
    startActivity(i);
}
此时效果如下：

异步AsyncTask的使用与原理分析

在第一次运行程序进入MainActivity，执行execute但在显示出图片之前，立即点击“加载图片”按钮，新打开一个MainActivity，我们发现这个MainActivity的进度条没有立即展示出进度出来，说明这个MainActivity的AsyncTask没有立即执行doInBackground()，这是因为AsyncTask内部使用的是线程池，相当于里面有一个线程队列，执行一次execute时会将一个下载任务加入到线程队列，只有前一个任务完成了，下一个下载任务才会开始执行。

为了达到我们想要的效果，我们自然想到把上一个任务给取消掉。的确，AsyncTask为我们提供了cancel()方法来取消一个任务的执行，但是要注意的是，cancel方法并没有能力真正去取消一个任务，其实只是设置这个任务的状态为取消状态，我们需要在doInBackground()下载中进行检测，一旦检测到该任务被用户取消了，立即停止doInBackground()方法的执行。

我们先修改MainActivity，根据不同业务需求，在不同地方进行任务的取消，我们这里在onPause()中进行任务的取消，在MainActivity方法中加入onPause()方法，如下：

1
2
3
4
5
6
7
8
@Override
protected void onPause() {
    super.onPause();
    if(asyncTask != null && asyncTask.getStatus() == AsyncTask.Status.<em>RUNNING</em>){
        //cancel只是将对应的任务标记为取消状态
        asyncTask.cancel(true);
    }
}
继续修改AsyncTask，在这里面进行任务是否被取消的检测，这里我们只简单修改下doInBackground()和onProgressUpdae()方法，实际项目中开自己的业务逻辑来控制，如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
@Override
protected Bitmap doInBackground(String... params) {
    String urlParams = params[0];//拿到execute()传过来的图片url
    Bitmap bitmap = null;
    URLConnection conn = null;
    InputStream is = null;
    try {
        URL url = new URL(urlParams);
        conn = url.openConnection();
        is = conn.getInputStream();
 
        for(int i = 0; i < 100; i++){
            if(isCancelled()){//通过isCancelled()判断任务任务是否被取消
                break;
            }
            publishProgress(i);
            Thread.<em>sleep</em>(50);//为了看清效果，睡眠一段时间
        }
        BufferedInputStream bis = new BufferedInputStream(is);
        bitmap = BitmapFactory.<em>decodeStream</em>(bis);
 
        is.close();
        bis.close();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return bitmap;
}
 
@Override
protected void onProgressUpdate(Integer... values) {
    super.onProgressUpdate(values);
    if(isCancelled()){//通过isCancelled()判断任务任务是否被取消
        return;
    }
    mPreogressBar.setProgress(values[0]);
}

在doInBackground()的for循环更新进度过程中，我们持续不断的监听任务十分被取消，一旦取消了，尽快退出doInBackground的执行，现在运行效果如下：

异步AsyncTask的使用与原理分析

可以看到，现在每次点击“加载图片”按钮，新的界面都会立即更新进度条，我们就业把前面的任务给取消掉了。

使用小结：

（1）AsyncTask中，只有doInBackground()方法是处于子线程中运行的，其他三个回调onPreExecute()、onPostExecute()、onProgressUpdate()都是在UI线程中进行，因此在这三个方法里面可以进行UI的更新工作；

（2）每一个new出的AsyncTask只能执行一次execute()方法，多次运行将会报错，如需多次，需要新new一个AsyncTask；

（3）AsyncTask必须在UI线程中创建实例，execute()方法也必须在UI线程中调用；

2、AsyncTask内部实现原理

进入AsyncTask源码，简单分析一下AsyncTask的内部实现。前面说到，AsyncTask内部封装了异步任务队列和Handler，那我们就从这两块入手。

2.1 AsyncTask的内部异步队列

在我们上面那个例子中，讲到第二个现象时，就可以直观的看到，AsyncTask的内部肯定是基于工作队列这种方式的，每次执行execute()就会把当前的任务加入到工作队列中。但是大家有没有发现这么个问题，我每次点击“加载图片”按钮，都会进入MainActivity的onCreate方法中去新建一个AsyncTask的对象，既然对象都是新的了，为什么AsyncTask中的工作队列还是能够正常管理呢？这就说明，AsyncTask内部的线程池、工作队列的定义都应该是static的，而static定义的变量是属于进程范围内的，只有这样，这些static的变量才能交给AsyncTask这个类来管理，而不是AsyncTask的具体子类对象。如下部分变量声明：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
 
    /**
     * 定义一个线程池，在线程池中有一个Runnable任务队列，用来存放、顺序执行任务
     */
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
 
    //AsyncTask内部默认使用的线程池
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    //自定义的一个Handler
    private static InternalHandler sHandler;</runnable></runnable>

可以看到，优线程池有关的都定义为了static类型，其中，SERIAL_EXECUTOR内部就定义了一个任务队列ArrayDequemTasks，当我们调用AsyncTask的execute()时，就会将当前任务加入到该队列中。先来看执行AsyncTask的execute()时的情景：

1
 
1
2
3
4
@MainThread
public final AsyncTask<params, result=""> execute(Params... params) {
return executeOnExecutor(<em>sDefaultExecutor</em>, params);
}</params,>
AsyncTask的execute()交给了executeOnExecutor()方法，将将默认的线程池作为参数传进来，进入executeOnExecutor方法中：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@MainThread
public final AsyncTask<params, result=""> executeOnExecutor(Executor exec,
        Params... params) {
    if (mStatus != Status.<em>PENDING</em>) {//1、这里判断当前AsyncTask是否正在执行或已执行完毕
        switch (mStatus) {
            case <em>RUNNING</em>:
                throw new IllegalStateException("Cannot execute task:"
                        + " the task is already running.");
            case <em>FINISHED</em>:
                throw new IllegalStateException("Cannot execute task:"
                        + " the task has already been executed "
                        + "(a task can be executed only once)");
        }
    }
    mStatus = Status.<em>RUNNING</em>;//2、设置正在执行的状态
    onPreExecute();//3、回调onPreExecute()方法
    mWorker.mParams = params;
    exec.execute(mFuture);//4、放到前面默认构造的线程池中去执行
    return this;
}</params,>
上面第一步，先判断当前AsyncTask是否正在运行或已经执行完毕，如果正在执行或执行完毕再次执行将抛出异常，这也正是我们前面在使用的时候谈到，同一个AsyncTask不能多次进行execute()的原因！到了第三步的时候，先去调用一下onPreExecute()方法，因为executeOnExecutor方法本身就是在UI线程中运行的，所以onPreExecute也会在UI线程中运行。第四步，才会开始讲当前AsyncTask任务加入到队列中，我们进入默认的线程池中去看一下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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) {
            <em>THREAD_POOL_EXECUTOR</em>.execute(mActive);
        }
    }
}</runnable></runnable>

在第四步执行execute时，实际就是调用的SerialExecutor中的execute方法，在这里面，先创建了一个Runnable对象，然后将这个Runnable对象添加到任务队列mTasks中，在当执行到这个Runnable时调用scheduleNext去队列中取出一个任务，然后交给另一个线程池去真正执行这个任务。

2.2 与UI线程进行交互-handler

AsyncTask内部通过自定义的static类型的InternalHandler和UI线程进行交互。InternalHandler实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
private static class InternalHandler extends Handler {
    public InternalHandler() {
        super(Looper.<em>getMainLooper</em>());
    }
 
    @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
    @Override
    public void handleMessage(Message msg) {
        AsyncTaskResult<!--?--> result = (AsyncTaskResult<!--?-->) msg.obj;
        switch (msg.what) {
            case <em>MESSAGE_POST_RESULT</em>:
                // There is only one result
                result.mTask.finish(result.mData[0]);
                break;
            case <em>MESSAGE_POST_PROGRESS</em>:
                result.mTask.onProgressUpdate(result.mData);
                break;
        }
    }
}
每当收到子线程发来的和UI线程进行通信的handler请求时，先从Message中拿到子线程发来的结果参数AsyncTaskResult，AsyncTaskResult里面封装了AsyncTask对象和数据信息，如下：
1
2
3
4
5
6
7
8
private static class AsyncTaskResult<data> {
    final AsyncTask mTask;
    final Data[] mData;
    AsyncTaskResult(AsyncTask task, Data... data) {
        mTask = task;
        mData = data;
    }
}</data>

然后根据不同状态调用不同方法，如果是MESSAGE_POST_RESULT状态，就调用AsyncTask的finish()方法，finish方法中会去判断当前任务十分被cancel，如果没有cancel则开始回调onPostExecute()方法；如果状态是MESSAGE_POST_PROGRESS，则回调onProgressUpdate()方法。

当子线程需要和UI线程进行通信时，就会通过这个handler，往UI线程发送消息。需要通过handler来发送消息，肯定是在子线程异步任务的时候才需要，在AsyncTask中需要handler的地方其实就是两个地方，一个是doInBackground()在运行过程中，需要更新进度值的时候；一个是doInBackground()运行完成后，需要回到到UI线程中的onPostExecute()方法的时候。

对于一：我们在doInBackground()中调用publicProgress()进行进度值的更新，因此在publicProgress()中肯定会有handler的身影，如下：

1
2
3
4
protected final void publishProgress(Progress... values) {
    if (!isCancelled()) {
        <em>getHandler</em>().obtainMessage(<em>MESSAGE_POST_PROGRESS</em>,
                new AsyncTaskResult

对于二：其实就是一个异步任务执行完后后的返回处理，而FutureTask正是处理处理Runnable运行返回结果的。

在2.1部分的executeOnExecutor方法中第四步，我们在执行execute(mFuture)，传入了一个mFuture，mFuture是在初始化AsyncTask的时候进行构建的，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
mFuture = new FutureTask<result>(mWorker) {
    @Override
    protected void done() {
        try {
            postResultIfNotInvoked(get());//这里面通过handler往UI线程发送消息
        } catch (InterruptedException e) {
            android.util.Log.<em>w</em>(<em>LOG_TAG</em>, e);
        } catch (ExecutionException e) {
            throw new RuntimeException("An error occurred while executing doInBackground()",
                    e.getCause());
        } catch (CancellationException e) {
            postResultIfNotInvoked(null);
        }
    }
};</result>
在上面的postResultIfNotInvoked()中会通过handler进行消息的发送。 

AsyncTask原理总结：

AsyncTask主要是对异步任务和handler的封装，在处理异步任务时，AsyncTask内部使用了两个线程池，一个线程池sDefaultExecutor是用来处理用户提交（执行AsyncTask的execute时）过来的异步任务，这个线程池中有一个Runnable异步任务队列ArrayDequemTasks，把提交过来的异步任务放到这个队列中；另一个线程池THREAD_POOL_EXECUTOR，用来真正执行异步任务的。在处理handler时，自定义了一个InternalHandler，在publicProgress()和doInBackground()运行完成后，会通过这个handler往UI线程发送Message。

3、AsyncTask在使用中的一个特殊情况

我们在使用AsyncTask的时候，一般会在onPreExecute()和onPostExecute()中进行UI的更新，比如等待图片的显示、进度条的显示...当我们一个Activity中正在使用AsyncTask进行文件的下载时，如果此时屏幕发生了旋转，Activity会进行re-onCreate，又会创建一个AsyncTask进行文件的下载，这个正是我们前面将取消任务的时候谈到的第二个现象，我们只需要在onPause()中进行取消cancel()即可。但是这样仅仅是解决了发生等待的情况，因为Activity再次进入了onCreate()方法，还是会进行文件的下载，为了解决这个问题，一种方案是通过判断onCreate(Bundle savedInstanceState)方法参数中的savedInstanceState==null？来判断是哪种情况，只有savedInstanceState==null时才去创建新的AsyncTask。

4、AsyncTask和Handler的比较

AsyncTask：

优点：AsyncTask是一个轻量级的异步任务处理类，轻量级体现在，使用方便、代码简洁上，而且整个异步任务的过程可以通过cancel()进行控制；

缺点：不适用于处理长时间的异步任务，一般这个异步任务的过程最好控制在几秒以内，如果是长时间的异步任务就需要考虑多线程的控制问题；当处理多个异步任务时，UI更新变得困难。

Handler:

优点：代码结构清晰，容易处理多个异步任务；

缺点：当有多个异步任务时，由于要配合Thread或Runnable，代码可能会稍显冗余。

总之，AsyncTask不失为一个非常好用的异步任务处理类，只要不是频繁对大量UI进行更新，可以考虑使用；而Handler在处理大量UI更新时可以考虑使用。

3、实现原理：
1）、线程池的创建：
在创建了AsyncTask的时候，会默认创建一个线程池ThreadPoolExecutor，并默认创建出5个线程放入到线程池中，最多可防128个线程；且这个线程池是公共的唯一一份。
2）、任务的执行：
在execute中，会执行run方法，当执行完run方法后，会调用scheduleNext()不断的从双端队列中轮询，获取下一个任务并继续放到一个子线程中执行，直到异步任务执行完毕。
3）、消息的处理：
在执行完onPreExecute()方法之后，执行了doInBackground()方法，然后就不断的发送请求获取数据；在这个AsyncTask中维护了一个InternalHandler的类，这个类是继承Handler的，获取的数据是通过handler进行处理和发送的。在其handleMessage方法中，将消息传递给onProgressUpdate()进行进度的更新，也就可以将结果发送到主线程中，进行界面的更新了。

相关文章：

猜你喜欢
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode