Android沿用了JAVA的线程模型，其中的线程也分为主线程和子线程，其中的主线程也叫UI线程，主线程的作用是运行四大组件以及处理他们和用户的交互，而子线程的作用是执行耗时任务，比如网络请求，I/O操作等。从Android3.0开始系统要求网络访问必须在子线程中进行，否则网络访问将会失败并抛出NetWorkThreadException这个异常，这样做的目的是为了避免主线程由于被耗时操作所阻塞从未出现ANR现象。
Android中的线程形态除了传统的Thread的Thread以外，还包含了AsyncTask、HandlerThread、以及IntentService，这三者的底层都是线程，但他们具有特殊的表现形式，同时在使用上也是各有优缺点。本篇博客我们就来简析一下AsyncTask、HandlerThread、以及IntentService这三种独特的线程表现形式。
（1）AsyncTask
先来看看AsyncTask的定义：
public abstract class AsyncTask<Params, Progress, Result> {
三种泛型类型分别代表“启动任务执行的输入参数”、“后台任务执行的进度”、“后台计算结果的类型”。在特定场合下，并不是所有类型都被使用，如果没有被使用，可以用java.lang.Void类型代替。
一个异步任务的执行一般包括以下几个步骤：
1.execute(Params... params)，执行一个异步任务，需要我们在代码中调用此方法，触发异步任务的执行。
2.onPreExecute()，在execute(Params... params)被调用后立即执行，一般用来在执行后台任务前对UI做一些标记。
3.doInBackground(Params... params)，在onPreExecute()完成后立即执行，用于执行较为费时的操作，此方法将接收输入参数和返回计算结果。在执行过程中可以调用publishProgress(Progress... values)来更新进度信息。
4.onProgressUpdate(Progress... values)，在调用publishProgress(Progress... values)时，此方法被执行，直接将进度信息更新到UI组件上。
5.onPostExecute(Result result)，当后台操作结束时，此方法将会被调用，计算结果将做为参数传递到此方法中，直接将结果显示到UI组件上。
下面是一个简单的AsyncTask的用法示例，创建MyTask类继承AsyncTask：
private class MyTask extends AsyncTask<String, Integer, String> {
//onPreExecute方法用于在执行后台任务前做一些UI操作
@Override
protected void onPreExecute() {
Log.i(TAG, "onPreExecute() called");
textView.setText("loading...");
}
//doInBackground方法内部执行后台任务,不可在此方法内修改UI
@Override
protected String doInBackground(String... params) {
Log.i(TAG, "doInBackground(Params... params) called");
try {
HttpClient client = new DefaultHttpClient();
HttpGet get = new HttpGet(params[0]);
HttpResponse response = client.execute(get);
if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
HttpEntity entity = response.getEntity();
InputStream is = entity.getContent();
long total = entity.getContentLength();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buf = new byte[1024];
int count = 0;
int length = -1;
while ((length = is.read(buf)) != -1) {
baos.write(buf, 0, length);
count += length;
//调用publishProgress公布进度,最后onProgressUpdate方法将被执行
publishProgress((int) ((count / (float) total) * 100));
//为了演示进度,休眠500毫秒
Thread.sleep(500);
}
return new String(baos.toByteArray(), "gb2312");
}
} catch (Exception e) {
Log.e(TAG, e.getMessage());
}
return null;
}
//onProgressUpdate方法用于更新进度信息
@Override
protected void onProgressUpdate(Integer... progresses) {
Log.i(TAG, "onProgressUpdate(Progress... progresses) called");
progressBar.setProgress(progresses[0]);
textView.setText("loading..." + progresses[0] + "%");
}
//onPostExecute方法用于在执行完后台任务后更新UI,显示结果
@Override
protected void onPostExecute(String result) {
Log.i(TAG, "onPostExecute(Result result) called");
textView.setText(result);
execute.setEnabled(true);
cancel.setEnabled(false);
}
//onCancelled方法用于在取消执行中的任务时更改UI
@Override
protected void onCancelled() {
Log.i(TAG, "onCancelled() called");
textView.setText("cancelled");
progressBar.setProgress(0);
execute.setEnabled(true);
cancel.setEnabled(false);
}
}
}
启用MyTask代码：
mTask = new MyTask();
mTask.execute("http://www.baidu.com");doInBackground(Params... params)是一个抽象方法，我们继承AsyncTask时必须覆写此方法；onPreExecute()、onProgressUpdate(Progress... values)、onPostExecute(Result result)、onCancelled()这几个方法体都是空的，我们需要的时候可以选择性的覆写它们；publishProgress(Progress... values)是final修饰的，不能覆写，只能去调用，我们一般会在doInBackground(Params...params)中调用此方法；
AsyncTask的工作原理：
们从execute(Params... params)作为入口，分析一下AsyncTask的执行流程，execute方法又会调用executeOnExecutor方法，他们的实现如下：
public final AsyncTask<Params, Progress, Result> execute(Params... params){
return executeOnExecuto(sDefaultExecutor,params);
}
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
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;
}
在上面的代码中，SDefalultExecutor实际上是一个串行的线程池，一个进程中所有的AsyncTask全部在这个线程池中排队执行，在executeOnExecutor方法中，AsyncTask的onPreEcecute方法最先执行，然后线程开始执行。
sDefaultExecutor是如何实现的,如下所示：
//串行任务执行器，其作用就是将多个任务一个一个的执行(execute())
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
//默认的任务执行器，默认为串行任务执行
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
//串行执行器的实现，AsyncTask.execute(param...) 方法最终是走到这里
//其实现就是将任务加入到队列中 一个个排队 去实现任务
private static class SerialExecutor implements Executor {
//线性双向队列 用来存储所有的AsyncTask任务
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
//正在执行的任务
Runnable mActive;
public synchronized void execute(final Runnable r) {
//串行执行多个任务核心代码
//将新的AsyncTask任务加入到双向队列中
mTasks.offer(new Runnable() {
public void run() {
try {
//执行任务
r.run();
} finally {
//当AsyncTask任务执行完毕后，执行下一个任务
scheduleNext();
}
}
});
//如果没有正在执行的任务 从任务队列中直接获取任务 执行
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
//取出队列头部任务 交给线程池执行
if ((mActive = mTasks.poll()) != null) {
//线程池执行该任务
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}从上述代码中,分析AsyncTask执行的任务是串行执行的过程,首先AsyncTask将FutureTask交给 SerialExecutor 的execute方法去处理, SerialExecutor 的execute方法会将FutureTask插入到mTasks(双向队列)中,如果没有正在执行的任务 mActive==null 从任务队列中直接获取任务 执行 scheduleNext 知道所有的任务执行完为止。
如何实现并行任务呢?
通过 executeOnExecutor 可自定义AsyncTask的执行方式，串行or并行，execute是串行执行，或者自定义线程池 asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, Params... params); 可实现并行执行任务
（2）HanderThread
我们的应用程序当中为了实现同时完成多个任务，所以我们会在应用程序当中创建多个线程。为了让多个线程之间能够方便的通信，我们会使用Handler实现线程间的通信。
下面我们看看如何在线程当中实例化Handler。在线程中实例化Handler我们需要保证线程当中包含Looper(注意：UI-Thread默认包含Looper)。
为线程创建Looper的方法如下：在线程run()方法当中先调用Looper.prepare()初始化Looper,然后再run()方法最后调用Looper.loop()，这样我们就在该线程当中创建好Looper。(注意：Looper.loop()方法默认是死循环)
我们实现Looper有没有更加简单的方法呢?当然有，这就是我们的HandlerThread。
使用步骤：
1.创建一个HandlerThread，及创建了一个包含Handler的线程：
HandlerThread handlerThread = new HandlerThread("leochin.com");
handlerThread.start(); //创建HandlerThread后一定要记得start()2.获取Handler的Looper
Looper looper = handlerThread.getLooper();3.创建Handler通过Looper初始化
Handler handler = new Handler(looper);通过以上三步我们就成功创建HandlerThread。通过handler发送消息，就会在子线程中执行。
如果想让HandlerThread退出，则需要调用handlerThread.quit();
HandlerThread的内部实现也十分简单，源码如下：
package android.os;
public class HandlerThread extends Thread {
int mPriority;
int mTid = -1;
Looper mLooper;
public HandlerThread(String name) {
super(name);
mPriority = Process.THREAD_PRIORITY_DEFAULT;
}
protected void onLooperPrepared() {
}
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}
从HandlerThread的实现来看，它和普通的Thread有显著的不同。普通Thread主要用于在run方法中执行一个耗时任务，而HandlerThread在内部创建了消息队列，外界需要通过Handler的消息方式来通知HandlerThread执行一个具体的任务。HandlerThread是一个很有用的类，它的一个具体使用场景是IntentService。
（3）IntentService
我们先来看看IntentService的特点：
- 它本质是一种特殊的Service,继承自Service并且本身就是一个抽象类
- 它可以用于在后台执行耗时的异步任务，当任务完成后会自动停止
- 它拥有较高的优先级，不易被系统杀死（继承自Service的缘故），因此比较适合执行一些高优先级的异步任务
- 它内部通过HandlerThread和Handler实现异步操作
- 创建IntentService时，只需实现onHandleIntent和构造方法，onHandleIntent为异步方法，可以执行耗时操作
IntentService的常规使用：
public class MyIntentService extends IntentService {
public static final String DOWNLOAD_URL="download_url";
public static final String INDEX_FLAG="index_flag";
public static UpdateUI updateUI;
public static void setUpdateUI(UpdateUI updateUIInterface){
updateUI=updateUIInterface;
}
public MyIntentService(){
super("MyIntentService");
}
/**
* 实现异步任务的方法
* @param intent Activity传递过来的Intent,数据封装在intent中
*/
@Override
protected void onHandleIntent(Intent intent) {
//在子线程中进行网络请求
Bitmap bitmap=downloadUrlBitmap(intent.getStringExtra(DOWNLOAD_URL));
Message msg1 = new Message();
msg1.what = intent.getIntExtra(INDEX_FLAG,0);
msg1.obj =bitmap;
//通知主线程去更新UI
if(updateUI!=null){
updateUI.updateUI(msg1);
}
//mUIHandler.sendMessageDelayed(msg1,1000);
LogUtils.e("onHandleIntent");
}
通过代码可以看出，我们继承了IntentService，这里有两个方法是必须实现的，一个是构造方法，必须传递一个线程名称的字符串，另外一个就是进行异步处理的方法onHandleIntent(Intent intent) 方法，其参数intent可以附带从activity传递过来的数据。这里我们的案例主要利用onHandleIntent实现异步下载图片，然后通过回调监听的方法把下载完的bitmap放在message中回调给Activity（当然也可以使用广播完成），最后通过Handler去更新UI。
IntentService原理分析：
首先看IntentService的onCreate方法：
@Override
public void onCreate() {
// TODO: It would be nice to have an option to hold a partial wakelock
// during processing, and to have a static startService(Context, Intent)
// method that would launch the service & hand off a wakelock.
super.onCreate();
HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
thread.start();
mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);
}当第一启动IntentService时，它的onCreate方法将会被调用，其内部会去创建一个HandlerThread并启动它，接着创建一个ServiceHandler（继承Handler），传入HandlerThread的Looper对象，这样ServiceHandler就变成可以处理异步线程的执行类了（因为Looper对象与HandlerThread绑定，而HandlerThread又是一个异步线程，我们把HandlerThread持有的Looper对象传递给Handler后，ServiceHandler内部就持有异步线程的Looper，自然就可以执行异步任务了），那么IntentService是怎么启动异步任务的呢？其实IntentService启动后还会去调用onStartCommand方法，而onStartCommand方法又会去调用onStart方法，我们看看它们的源码：
@Override
public void onStart(Intent intent, int startId) {
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.obj = intent;
mServiceHandler.sendMessage(msg);
}
/**
* You should not override this method for your IntentService. Instead,
* override {@link #onHandleIntent}, which the system calls when the IntentService
* receives a start request.
* @see android.app.Service#onStartCommand
*/
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
onStart(intent, startId);
return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
}从源码我们可以看出，在onStart方法中，IntentService通过mServiceHandler的sendMessage方法发送了一个消息，这个消息将会发送到HandlerThread中进行处理（因为HandlerThread持有Looper对象，所以其实是Looper从消息队列中取出消息进行处理，然后调用mServiceHandler的handleMessage方法），我们看看ServiceHandler的源码：
private final class ServiceHandler extends Handler {
public ServiceHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
onHandleIntent((Intent)msg.obj);
stopSelf(msg.arg1);
}
}里其实也说明onHandleIntent确实是一个异步处理方法（ServiceHandler本身就是一个异步处理的handler类），在onHandleIntent方法执行结束后，IntentService会通过 stopSelf(int startId)方法来尝试停止服务。这里采用stopSelf(int startId)而不是stopSelf()来停止服务，是因为stopSelf()会立即停止服务，而stopSelf(int startId)会等待所有消息都处理完后才终止服务。最后看看onHandleIntent方法的声明：
protected abstract void onHandleIntent(Intent intent);到此我们就知道了IntentService的onHandleIntent方法是一个抽象方法，所以我们在创建IntentService时必须实现该方法，通过上面一系列的分析可知，onHandleIntent方法也是一个异步方法。这里要注意的是如果后台任务只有一个的话，onHandleIntent执行完，服务就会销毁，但如果后台任务有多个的话，onHandleIntent执行完最后一个任务时，服务才销毁。最后我们要知道每次执行一个后台任务就必须启动一次IntentService，而IntentService内部则是通过消息的方式发送给HandlerThread的，然后由Handler中的Looper来处理消息，而Looper是按顺序从消息队列中取任务的，也就是说IntentService的后台任务时顺序执行的，当有多个后台任务同时存在时，这些后台任务会按外部调用的顺序排队执行，我们前面的使用案例也很好说明了这点。
好了，到这里我们就把AsyncTask、HandlerThread、IntentService三个线程的特殊表现形式分析完了！
参考文章：
https://www.cnblogs.com/ldq2016/p/8192230.html
https://blog.csdn.net/lmj623565791/article/details/47079737/
