Android 消息机制Handler完全解析(一)
Android 消息机制Handler完全解析(二)
Android Handler消息机制-消息屏障(三)
Android Handler消息机制完全解析(四)-IdleHandler和epoll机制
Android Handler消息机制(五)-HandlerThread完全解析
关于Handler的相关文章我们已经学习了四篇了，这一篇我们来学习下另一个Handler相关的知识HandlerThread，从名字来看它有Handler和Thread应该跟这两者有关，同样我们还是带着问题来学习今天的内容
- 为什么要有HandlerThread
- HandlerThread解决了什么问题
首先Handler是可以跨线程进行通讯的，大家想象一个场景:有两个Thread，ThreadA和ThreadB，如何在ThreadB中声明一个Handler对象且ThreadB中的Handler发送消息会发送到ThreadA中处理？通过前面的学习我们知道在Handler有一个传递Looper对象的构造方法
public Handler(@NonNull Looper looper) {this(looper, null, false);
}
因此我们可以在ThreadB中获取到ThreadA中的looper对象，然后声明Handler的时候将此looper传递给Handler对象，这样就可以达到在ThreadB中声明的Handler发送的消息会发送到ThreadA中处理。来看一段代码
Thread threadA = new Thread(new Runnable() {Looper looper;@Overridepublic void run() {Looper.prepare();looper = Looper.myLooper();Looper.loop();}public Looper getLooper() {return looper;}
});
threadA.start();Handler workHandler = new Handler(threadA.getLooper()) {@Overridepublic void handleMessage(@NonNull Message msg) {// dosomething}};
如上所示第16行在主线程声明一个Handler的时候传递了threadA的Looper，这样通过workHandler发送的消息就能在threadA中收到，但是这样有一个问题就是上述threadA.getLooper()这个方法获取不到，因为在实例化handler的时候的Runnable是一个匿名内部类，而外部类不能直接访问匿名内部类的属性和方法，那么怎么办呢？我们可以将将Thread封装一下
public class MyHandlerThread extends Thread {Looper looper;MyHandlerThread(String name) {super(name);}@Overridepublic void run() {super.run();Looper.prepare();looper = Looper.myLooper();Looper.loop();}public Looper getLooper() {return looper;}
}
于是我们调用就可以像下面这样调用
MyHandlerThread threadA = new MyHandlerThread("threadTest");
threadA.start();
Handler workHandler = new Handler(threadA.getLooper());
这样封装之后似乎在线程中声明一个Handler简洁了很多，因为我们把Looper的一些操作封装在run方法里。但是这样有并发的问题，在第二行调用threadA.start之后会运行MyHandlerThread的run方法并对looper进行赋值(这个过程是在子线程中执行的)，而主线程的代码运行到第三行时会调用threadA.getLooper方法，此时有可能子线程还未对其进行赋值，也就是说此时threadA.getLooper可能为空。怎么解决这种问题呢？鉴于上述一系列问题所以谷歌给我们封装了一个HandlerThread，我们来看看它是怎么解决这个并发问题的呢？也就是说它是怎么确保执行threadA.getLooper时looper一定是有值的。要想彻底弄明白这个问题，需要对多线程并发有一定的了解，首先要理解synchronized关键字，我在这里写两段伪代码
public class Test {public void test1() {synchronized (this) {code1}}public void test2() {synchronized (this) {code2}}
}
问题来了，test1中的code1和test2中的code2是互斥访问的吗？答案是的，因为者两者持有的是同一把锁所以同一时刻只能执行一个。如果是下面这样就不会互斥
public class Test {public void test1() {synchronized (obj1) {code1}}public void test2() {synchronized (obj2) {code2}}
}
了解synchronized还不够，还需要对多线程的wait和notify有所了解，这里我直接上一个实例，这个实例就是利用多线程的wait和notify方法，来达到等待、唤醒的一个操作
public class ThreadA extends Thread {private Object obj;public ThreadA(Object obj) {this.obj = obj;}@Overridepublic void run() {synchronized (obj) {try {System.out.println("wait之前的时间:" + TimeUtils.getDate(System.currentTimeMillis()));obj.wait();System.out.println("wait之后的时间:" + TimeUtils.getDate(System.currentTimeMillis()));} catch (InterruptedException e) {throw new RuntimeException(e);}}}
}
首先定义一个ThreadA它继承自Thread在构造方法中接收一个Object对象用来加锁，并重写run方法，在run方法中调用wait
public class ThreadB extends Thread {private Object obj;public ThreadB(Object obj) {this.obj = obj;}@Overridepublic void run() {synchronized (obj) {System.out.println("notify之前的时间:" + TimeUtils.getDate(System.currentTimeMillis()));obj.notify();System.out.println("notify之后的时间:" + TimeUtils.getDate(System.currentTimeMillis()));}}
}
然后定义一个ThreadB与ThreadA类似，只不过它在run方法里调用notify方法，然后再main函数调用
Object object = new Object();
ThreadA threadA = new ThreadA(object);
threadA.start();Thread.sleep(3000);ThreadB threadB = new ThreadB(object);
threadB.start();
大家先想一想如何打印，打印结果
wait之前的时间:2024-10-29 17:16:09
notify之前的时间:2024-10-29 17:16:12
notify之后的时间:2024-10-29 17:16:12
wait之后的时间:2024-10-29 17:16:12
发现没有在threadA执行到wait方法后就释放了锁并进入了等待状态，后面的代码暂时不执行，等threadB拿到锁并调用notify方法并且将代码块执行完后将锁释放，此时ThreadA中的wait收到了notify的通知，继续后面的代码执行。这种场景在并发编程中也是经常用到，大家要记住这种场景的处理方式即加锁+wait+notify的方式。
回想一下我们刚才遇到的问题即如何确保threadA.getLooper()方法一定有不为null的返回值。这里是不是提供了一个思路:可以对getLooper方法加锁并进行判断如果looper为空则调用wait等待，run方法也加锁当完成了对mLooper的赋值之后notify一下，此时getLooper方法被唤醒并且looper已经完成了赋值。
说了这么多好像HandlerThread还没正式登场，上面我们讲的内容其实就是HandlerThread的主要原理，HandlerThread的源码并不多总共还不到200行，我精简一下
public class HandlerThread extends Thread {...Looper mLooper;private @Nullable Handler mHandler;/*** Call back method that can be explicitly overridden if needed to execute some* setup before Looper loops.*/protected void onLooperPrepared() {}@Overridepublic 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;}...
}
可以看到首先HandlerThread是一个线程类它继承自Thread，并且对其进行了封装，在run方法里调用了Looper.prepare()和Looper.loop()方法，第17行和33行的锁是不是就跟我们上面讲的实例是一样，在调用getLooper方法时会判断mLooper是否为null,如果mLooper为null说明run方法里还未对mLooper赋值，此时调用wait方法进入等待状态且getLooper方法会将锁释放，run方法拿到锁并对mLooper赋值之后调用notifyAll方法此时getLooper收到这个通知，此时会再次判断mLooper是否为空，由于此时在run方法里已经对mLooper进行了赋值因此此时mLooper是不为空的，所以会执行return mLooper，这样getLooper就确保了mLooper一定有值。
关于HandlerThread的源码以及封装的过程就讲到这里，这也是关于Handler的第五篇文章了，相信这五篇文章的内容足以解决你工作和面试中的问题。
如果大家有疑问或者发现错误，欢迎在下方留言，我会在第一时间回答！！
如果觉得文章对你有帮助就帮忙点个赞吧。