本来准备今天整理一下IntentService的源码解析，但是发现必须先总结一个HandlerThread的知识点才可以讲它，所以我今天就讲一下HandlerThread的使用及源码解析。
HandlerThread的使用
public void startHandlerThread(){
final HandlerThread myHandlerThread = new HandlerThread("myHandlerThread");
myHandlerThread.start();
workHandler = new Handler((myHandlerThread.getLooper())){
@Override
public void handleMessage(Message message){
super.handleMessage(message);
switch (message.what){
case 0:
Log.d(TAG, "收到来自主线程的消息.."+Thread.currentThread().getName());
break;
case 1:
Log.d(TAG, "收到来自子线程的消息.."+Thread.currentThread().getName());
break;
}
}
};
workHandler.sendEmptyMessage(0);
new Runnable(){
@Override
public void run() {
workHandler.sendEmptyMessage(1);
}
}.run();
}
程序运行结果打印如下
02-26 20:06:34.195 30062-30101/com.txVideo.demo D/LoadingActivity: 收到来自主线程的消息..myHandlerThread
02-26 20:06:34.195 30062-30101/com.txVideo.demo D/LoadingActivity: 收到来自子线程的消息..myHandlerThread
这段代码中我们创建了一个HandlerThread的实例对象myHandlerThread，并在workHandler中执行相关的操作.最终可以就看出不管是在主线程还是子线程发送消息，都是在这个myHandlerThread线程中工作。
源码分析
首先我们开始看HandlerThread.java的源码
public class HandlerThread extends Thread {
int mPriority;
int mTid = -1;
Looper mLooper;
private @Nullable Handler mHandler;
public HandlerThread(String name) {
super(name);
mPriority = Process.THREAD_PRIORITY_DEFAULT;
}
public HandlerThread(String name, int priority) {
super(name);
mPriority = priority;
}
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;
}
public Looper getLooper() {
if (!isAlive()) {
return null;
}
// If the thread has been started, wait until the looper has been created.
synchronized (this) {
while (isAlive() && mLooper == null) {
try {
wait();
} catch (InterruptedException e) {
}
}
}
return mLooper;
}
@NonNull
public Handler getThreadHandler() {
if (mHandler == null) {
mHandler = new Handler(getLooper());
}
return mHandler;
}
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;
}
}
看完源码，我们可以看出，HandlerThread其本质是Thread的子类，也就是一个子线程，里面有三个常量
int mPriority;
int mTid = -1;
Looper mLooper;
- mPriority表示线程的优先级
- mTid表示线程的标识符
- mLooper一个Looper实例，这是HandlerThread与Thread的最大不同点。
既然是线程，那么我们看它究竟在线程里做了些什么操作
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}
从run方法里我们可以看出，它所做的操作就是在这个线程中调用一个Looper对象的loop方法，然后当我们开始运行这个HandlerThread实例对象时，它的Looper也就开始了循环.那如何停止它呢？
public boolean quit() {
Looper looper = getLooper();
if (looper != null) {
looper.quit();
return true;
}
return false;
}
停止时就用到了上述的quit()方法。
那么接下来我们通过用法结合HandlerThread线程的原理，来分析一下它的运行过程。那么回到我们最开始的使用来逐行分析。
final HandlerThread myHandlerThread = new HandlerThread("myHandlerThread");
myHandlerThread.start();
这里我们创建了一个HandlerThread的实例对象myHandlerThread,通过调用start()方法来开启了这个线程中的Looper循环。
workHandler = new Handler((myHandlerThread.getLooper())){
@Override
public void handleMessage(Message message){
super.handleMessage(message);
switch (message.what){
case 0:
Log.d(TAG, "收到来自主线程的消息.."+Thread.currentThread().getName());
break;
case 1:
Log.d(TAG, "收到来自子线程的消息.."+Thread.currentThread().getName());
break;
}
}
};
接下来我们创建了一个执行myHandlerThread的工作handler，它负责HandlerThread做实际的业务，它在创建时，通过myHandlerThread的getLooper()方法来获取Looper对象，然后利用这个Looper对象来创建了这个Handler，从上篇Handler的源码分析中我们可以得知，每一个Looper维护了自己的一个消息队列，因此当我们给这个Handler发送消息时，其实也就是给myHandlerThread线程里的Looper对象发送消息，因此我们只需要在执行业务时调用
workHandler.sendEmptyMessage(0); //主线程发送消息
new Runnable(){
@Override
public void run() {
workHandler.sendEmptyMessage(1);
}
}.run(); // 子线程里发送消息
我们可以通过打印结果看出其都是运行在myHandlerThread的线程中的，当我们使用完毕时，还需要关闭myHandlerThread中的Looper循环，也就是调用如下代码
myHandlerThread.quit()
HandlerThread的使用还是很简单的，那么接下来我们总结一下它的工作原理:
- 新创建一个HandlerThread实例对象，并调用start()方法，它会开启线程中的Looper循环，不停地遍历所收到的消息
- 新建一个Handler，它拥有和这个HandlerThread一样的Looper对象，共同接收和遍历同一个消息队列。
- 发送消息给Handler，同时触发HandlerThread中的Looper的消息获取，然后在HandlerThread的线程中就开始执行相对应的处理消息的代码.
总结一下它的特点
- 它是Thread的子类，其本质就是一个单一的子线程
- 因为它和Handler的工作原理类似，所以它的任务执行是串行的不是并行的。
- 使用时结合Handler使用,使用完毕后需手动关闭线程中的Looper循环。
通过全篇的分析，其实HandlerThread就是为了分担主线程中的压力，去做一些其他的操作。
今天的HandlerThread原理就总结到这里啦，觉得对您有帮助记得点个赞~
网友评论