一、概述
HandlerThread 看名字，应该包含Handler和Thread，然而，你以为你以为的就是你以为的？哈哈。 开个玩笑，言归正传。 HandlerThread 继承自Thread，自身包含一个Looper。或许你该问，既然没有Handler相关的东西，为什么交HandlerThread。其实这个跟Android的Handler工作机制相关，Handler对象的生成是需要在有Looper的线程中，如果在没有Looper的线程中生成Handler对象，将会爆出异常。
IntentService 是一个继承自Service的类，他内部实现原理是依赖HandlerThread来实现的，IntentService启动了一个后台服务，在该后台服务中启动一个线程来工作，当线程工作完后，自动的安全关闭该服务，避免耗费资源。
二、源码分析
还是结合源码来分析这两个类的工作原理，首先看下HandlerThread的源码实现,源码不是很多，我就全部放进来了：
public class HandlerThread extends Thread {//继承自Thread类
int mPriority;
int mTid = -1;
Looper mLooper;//内部维护一个Looper
public HandlerThread(String name) {
super(name);
mPriority = Process.THREAD_PRIORITY_DEFAULT;//线程优先级用的默认优先级
}
public HandlerThread(String name, int priority) {
super(name);
mPriority = priority;
}
protected void onLooperPrepared() { //用户可以重写该方法，在Looper.loop()之前做一些准备工作
}
@Override
public void run() {//线程体执行的内容
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();//获得一个Looper
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();//hook onLooperPrepared
Looper.loop();//启动消息循环
mTid = -1;
}
public Looper getLooper() {
if (!isAlive()) {
return null;
}
synchronized (this) {
while (isAlive() && mLooper == null) {
try {
wait();
} catch (InterruptedException e) {
}
}
}
return mLooper;
}
public boolean quit() {
Looper looper = getLooper();
if (looper != null) {
looper.quit();
return true;
}
return false;
}
public boolean quitSafely() {
Looper looper = getLooper();
if (looper != null) {
looper.quitSafely();
return true;
}
return false;
}
public int getThreadId() {
return mTid;
}
}
从上述代码中可以看出:
1.HandlerThread确实是一个线程；
2.HandlerThread中维护了一个Looper对象，在线程执行体内启动了Looper.loop()。
下面看下IntentService的源码,代码量也不是很多：
public abstract class IntentService extends Service {
private volatile Looper mServiceLooper;
private volatile ServiceHandler mServiceHandler;//内部使用了一个Handler
private String mName;
private boolean mRedelivery;
private final class ServiceHandler extends Handler {
public ServiceHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
onHandleIntent((Intent)msg.obj);//收到消息后，回调onHandleIntent()方法 注意该方法的调用是在非主线程中调用的
stopSelf(msg.arg1);//待线程体执行结束后，结束该服务
}
}
public IntentService(String name) {
super();
mName = name;
}
public void setIntentRedelivery(boolean enabled) {
mRedelivery = enabled;
}
@Override
public void onCreate() {
super.onCreate();
HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");//在Service
OnCreate中，使用HandlerThread 启动一个带Looper的线程
thread.start();
mServiceLooper = thread.getLooper();//获取到Looper
mServiceHandler = new ServiceHandler(mServiceLooper);//生成一个Handler ，前边讲过，Handler的生成需要Looper。
}
@Override
public void onStart(@Nullable Intent intent, int startId) {
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.obj = intent;
mServiceHandler.sendMessage(msg);//在onStart()方法中发送一个消息
}
@Override
public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
onStart(intent, startId);
return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
}
@Override
public void onDestroy() {
mServiceLooper.quit();
}
@Override
@Nullable
public IBinder onBind(Intent intent) {
return null;
}
@WorkerThread
protected abstract void onHandleIntent(@Nullable Intent intent);//重写方法 讲耗时的内容在该方法体实现
}
三、总结
通过上边两个类的源码分析，我们可以总结出：
1.HandlerThread是一个线程，在线程启动的时候启动消息队列；
2.IntentService 是一个继承自Service的类，他通过在Service服务中开启HandlerThread的消息队列；
3.使用HandlerThread的Looper来生成一个Handler对象，在onStart()方法中发送消息，然后执行onHandleIntent()方法；
4.onHandleIntent在子线程中执行，我们可以将耗时任务放在这个方法中实现。
至于Handler机制不在本文讨论，但本文的理解需要基于Handler工作机制。有机会再给大家分析Handler的工作机制。
感谢你的耐心阅读，如有错误，欢迎指正。如果本文对你有帮助，记得点赞.
