有时候，一个东西很简单看一眼就记住了，感觉不值得写一遍文章来记录。但是隔一段时间以后，突然回想起来，发现又忘了，这时候又得重新看一遍。很纠结这种情况到底要不要记录一下，最后还是决定记录一下吧。。。
当我们在子线程中实例化Handler的时候，需要先调用Looper.prepare()方法，然后实例化一个Handler对象，最后在开始loop循环。如下所示：
new Thread("子线程") {
@Override
public void run() {
//Looper准备
Looper.prepare();
Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
//在这里处理消息
}
};
//开启loop循环，死循环，要写在最后面
Looper.loop();
}
}.start();
如果每次都得写这么一段代码那就没意思了。Android给我们提供了一个类似的类，可以直接使用。这个类就是HandlerThread。
HandlerThread 是 Android 中的一个便捷类，用于在后台线程中处理任务。它内部创建了一个 Looper，可以与 Handler 配合使用来处理消息或者运行任务。
以下是如何使用 HandlerThread 的基本步骤：
- 创建一个
HandlerThread实例。 - 启动线程。
- 创建一个与该线程的
Looper关联的Handler。 - 使用该
Handler发送消息或者运行任务。
以下是一个简单的示例：
// 创建一个 HandlerThread
HandlerThread handlerThread = new HandlerThread("MyHandlerThread");
// 启动线程
handlerThread.start();
// 创建一个与该线程的 Looper 关联的 Handler
Handler handler = new Handler(handlerThread.getLooper());
// 使用该 Handler 发送消息或者运行任务
handler.post(new Runnable() {
@Override
public void run() {
// 在这里执行你的任务
}
});
当你不再需要 HandlerThread 时，应该调用其 quit() 或 quitSafely() 方法来停止线程。这将断开与 Looper 的连接，并且线程将在完成所有剩余工作后终止。
HandlerThread 类部分代码
public class HandlerThread extends Thread {
int mPriority;
//线程id
int mTid = -1;
Looper mLooper;
//Handler实例，可能为null
private @Nullable Handler mHandler;
public HandlerThread(String name) {
super(name);
mPriority = Process.THREAD_PRIORITY_DEFAULT;
}
@Override
public void run() {
mTid = Process.myTid();
//注释1处
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
//注意，这里是死循环
Looper.loop();
//当退出循环的时候，将线程id重置为-1。
mTid = -1;
}
public Looper getLooper() {
if (!isAlive()) {
return null;
}
//如果线程已经被启动了，等待looper对象创建完毕。
synchronized (this) {
while (isAlive() && mLooper == null) {
try {
wait();
} catch (InterruptedException e) {
}
}
}
return mLooper;
}
}
在注释1处，当线程启动的时候，调用Looper.prepare()来初始化当前线程的Looper对象。初始完毕后，在同步代码块中为mLooper对象赋值。
注意一下getLooper()方法。如果线程还没启动的化，返回null。否则需要等待 mLooper对象不为null才返回。
Android 系统中的 IntentService 用到了 HandlerThread
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();
//注释1处，创建了一个HandlerThread对象，并start。
HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
thread.start();
//注释2处，获取HandlerThread内部的Looper对象。
mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);
}
注释1处，创建了一个HandlerThread对象，并start。
注释2处，获取HandlerThread内部的Looper对象。
附：IntentService 源码分析
8.0以后，优先使用JobIntentService
IntentService自动在工作线程执行任务，避免阻塞主线程。执行完毕任务以后自动停止，内部使用Handler的方式处理用户发送的请求
使用方式
自定义MyIntentService集成IntentService，实现onHandleIntent方法，在这里处理逻辑。
public class MyIntentService extends IntentService {
private static final String TAG = "MyIntentService";
public MyIntentService() {
super("MyIntentService");
}
@Override
public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
Log.d(TAG, "onStartCommand: "+startId);
return super.onStartCommand(intent, flags, startId);
}
@Override
protected void onHandleIntent(@Nullable Intent intent) {
//注释1处，处理具体逻辑
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Log.d(TAG, "onHandleIntent: thread id="+Thread.currentThread().getId());
}
@Override
public void onDestroy() {
super.onDestroy();
Log.d(TAG, "onDestroy: MyIntentService");
}
}
注释1处，在onHandleIntent方法中，处理具体逻辑，注意是在后台线程。
每次启动service的时候，都会调用onStartCommand方法。也就是说IntentService是可以处理多个任务的。
@Override
public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
onStart(intent, startId);
return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
}
内部调用了onStart方法。
@Override
public void onStart(@Nullable Intent intent, int startId) {
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.obj = intent;
//注释1处，通过ServiceHandler来发送消息到后台执行。
mServiceHandler.sendMessage(msg);
}
注释1处，通过ServiceHandler来发送消息到后台执行。我们来看下ServiceHandler。
private volatile Looper mServiceLooper;
private volatile ServiceHandler mServiceHandler;
private String mName;
private boolean mRedelivery;
//内部使用handler来处理用户的请求
private final class ServiceHandler extends Handler {
public ServiceHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
//注释1处，抽象方法，处理逻辑，是在工作线程执行的
onHandleIntent((Intent)msg.obj);
//执行完毕停止服务
stopSelf(msg.arg1);
}
}
注释1处，抽象方法，处理逻辑，是在工作线程执行的。
mServiceHandler的初始化
@Override
public void onCreate() {
super.onCreate();
//使用HandlerThread 方便的获取一个Looper
HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
//调用start方法以后，Looper调用loop()方法开始分发消息
thread.start();
mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);
}
Service创建的时候会调用onCreate方法创建一个具有Looper对象的后台线程HandlerThread，然后来初始化mServiceHandler。
关于stopSelf(int startId)方法，每次启动的时候都会有一个对应的startId，在onStartCommand方法回调里面有这个startId，
onStartCommand(@Nullable Intent intent, int flags, int startId)，stopSelf方法中会判断只有当startId==我们传入的最后一个startId的时候，才会真正停止。比如说我们快速startService 6次，生成的startId的分别是1,2,3,4,5,6那么，stopSelf(int startId)方法只有当参数为6的时候才会停止服务。当服务停止以后会回调service的onDestroy方法，在这里mServiceLooper会退出，所以mServiceHandler的handleMessage也不会被调用了。
@Override
public void onDestroy() {
mServiceLooper.quit();
}
