【Android学习】线程的其他方式：AsyncTask、IntentService、HandlerThread、ThreadPoolExecutor

1，AsyncTask

1）概念

底层封装了线程和Handler。

AsyncTask是一种轻量级的异步任务类，它可以在线程池中执行后台任务，然后把执行的进度和最终结果传递给主线程中更新UI。

AsyncTask实际上是串行执行的。

2）场景

方便子线程更新UI。耗时任务放在doInBackground中。

但不适合特别耗时的后台任务（建议使用线程池）。

3）应用

①AsyncTask的实例必须在主线程中创建，AsyncTask类必需在主线程中加载（第一次访问AsyncTask必须发生在主线程）。
②execute方法必须在主线程中调用。
③不要手动的调用onPreExecute，onPostExecute，doInBackground，onProgressUpdate这几个方法。
④一个AsyncTask对象只能被执行一次（即只能调用一次execute方法），否则会出现运行时异常。
⑤Android1.6之前，AsyncTask是串行执行任务的。
Android1.6之后可在线程池中并行处理任务。
Android3.0，为了避免AsyncTask所带来的并发错误，又采用一个线程来串行执行任务。

在3.0后续版本，通过AsyncTask的executeOnExecutor方法来并行的执行任务。（见- 5）问题 -①问题：无法进入doInBackground）

4）AsyncTask类

AsyncTask是一个抽象的泛型类。

①3个泛型参数

public abstract class AsyncTask<Params, Progress, Result>

–Params 表示参数类型
–Progress 表示后台任务的执行进度的类型
–Result 表示后台任务返回结果的类型

对于不需要传递的参数，可用Void代替。

②4个核心方法

–onPreExecute()
在主线程中执行，在异步任务执行之前调用，用于做准备工作。

–doInBackground(Params…params)
在线程池中执行，用于执行异步任务。最后会返回计算结果给onPostExecute。
在这个方法中可以通过publishProgress方法更新任务进度，publishProgress会调用onProgressUpdate方法。

–onProgressUpdate(Progress…values)
在主线程中执行，当后台任务的执行进度改变时调用。

–onPostExecute(Result result)
在主线程中执行，在异步任务执行之后调用。
result为doInBackground的返回值。

–onCancelled()
在主线程中执行，异步任务取消时调用，这个适合onPostExecute不会被调用。

5）问题

①问题：无法进入doInBackground

在实际应用中，遇到很奇怪的问题，有时候AsyncTask无法进入doInBackground中。通过参阅http://blog.youkuaiyun.com/mddy2001/article/details/17127065文章，解决了问题。要么不用AsyncTask，直接用Thread实现。要么将调用execute方法，改为调用task.executeOnExecutor(Executors.newCachedThreadPool());
原因是，execute()提交的任务，按先后顺序每次只运行一个。相当于同一时间，只有一个线程在再执行任务。而executeOnExecutor，让所有线程并发执行。

②demo

package com.luo.activity;  

import java.util.ArrayList;  
import java.util.Iterator;  
import java.util.List;  

import android.app.Activity;  
import android.os.AsyncTask;  
import android.os.Bundle;  

public class MainActivity extends Activity {  

    protected List<AsyncTask<Void, Void, Integer>> mAsyncTasks = new ArrayList<AsyncTask<Void, Void, Integer>>();  

    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        setAsync();  
    }  

    public void putAsyncTask(AsyncTask<Void, Void, Integer> asyncTask) {  
        mAsyncTasks.add(asyncTask.execute());  
    }  

    public void clearAsyncTask() {  
        Iterator<AsyncTask<Void, Void, Integer>> iterator = mAsyncTasks  
                .iterator();  
        while (iterator.hasNext()) {  
            AsyncTask<Void, Void, Integer> asyncTask = iterator.next();  
            if (asyncTask != null && !asyncTask.isCancelled()) {  
                asyncTask.cancel(true);  
            }  
        }  
        mAsyncTasks.clear();  
    }  

    private void setAsync() {  

        MainActivity.this.clearAsyncTask();  
        MainActivity.this.putAsyncTask(new AsyncTask<Void, Void, Integer>() {  

            @Override  
            protected void onPreExecute() {  
                super.onPreExecute();  

            }  

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

                    return 0;  

            }  

            @Override  
            protected void onPostExecute(Integer result) {  
                super.onPostExecute(result);  

                if (result == 0) {  

                }   
            }  
        });  
    }  

} 

6）AsyncTask工作原理

一个进程中的所有AsyncTask都在一个串行线程池中排队执行。

AsyncTask中有两个线程池（SerialExecutor和THREAD_POOL_EXECUTOR）和一个Handler（InternalHandler）。
–SerialExecutor
用于任务排队，内部使用了一个队列，在一个同步方法内不断的将队列的任务加入到 threadPoolExecutor执行。默认是串行的线程池。
–THREAD_POOL_EXECUTOR
用于执行指定的任务。
–InternalHandler
用于将执行环境从线程池切换到主线程。
AsyncTask内部就是通过InternalHandler来发送任务执行的进度以及执行结束等消息。

AsyncTask排队执行过程：
系统先把参数Params封装为FutureTask对象，它相当于Runnable，接着FutureTask交给SerialExcutor的execute方法，它先把FutureTask插入到任务队列tasks中，如果这个时候没有正在活动的AsyncTask任务，那么就会执行下一个AsyncTask任务，同时当一个AsyncTask任务执行完毕之后，AsyncTask会继续执行其他任务直到所有任务都被执行为止。

关于线程池，AsyncTask对应的线程池ThreadPoolExecutor都是进程范围内共享的，都是static的，所以是AsyncTask控制着进程范围内所有的子类实例。由于这个限制的存在，当使用默认线程池时，如果线程数超过线程池的最大容量，线程池就会爆掉(3.0默认串行执行，不会出现这个问题)。针对这种情况。可以尝试自定义线程池，配合AsyncTask使用。

2，IntentService

3，HandlerThread

1）概念

继承了Thread。在它的内部可以使用Handler。

普通的Thread主要用于在run方法中执行一个耗时任务，而HandlerThread在内部创建了消息队列，外界需要通过Handler的消息方式来通知HandlerThread执行一个具体的任务。

2）实现

在run方法中通过Looper.prepare()创建消息队列，并通过Looper.loop()来开启消息循环，允许创建Handler。

run方法是一个无限循环，当不需要时需要退出：用quit或quitSafely方法。

3）场景

HandlerThread的一个具体使用场景是IntentService。

4，ThreadPoolExecutor 线程池