一、什么是Handler机制
定义：
Handler是用来结合线程的消息队列来发送、处理"Message对象"和"Runnable对象"的工具。
通常的来说，就是我们在线程之间处理消息通知及任务调度的工具。
二、Handler机制原理
先捋一遍源码，画个时序图，然后等下逐一说明。
-
相关类
Handler机制的实现离不开与之相关的其他三个类，Message是Handler发送的消息实体，大部分的消息都是通过Message来封装传递的；MessageQueue是用来将消息按顺序排队的队列；Looper本质就是一个循环，不停的从MessageQueue中取出消息然后处理。
-
执行过程
首先，如上图所示任务的开始是由创建一个Message开始的，Message创建完毕后交给Handler对象发送，
sendMessage和sendMessageDelay最终都是在底层调用了sendMessageAtTime()方法，将Message对象放入MessageQueue中的。之后，由Looper的
loop()方法循环从MessageQueue中取出Message对象，调用message.getTarget ()获取到发送消息的Handler对象，然后再调用handler.dispatchMessage()方法将信息分发给对应handler执行。最后，Handler在
dispatchMessage()方法中判断是否有callback 存在，存在则执行callback的onMessageHandler()，最终交由Message.callback执行；否则则执行handler的onMessageHandler()方法。public interface Callback {// callback接口 public boolean handleMessage(Message msg); } public void handleMessage(Message msg) { } public void dispatchMessage(Message msg) { if (msg.callback != null) { /* * callback是msg中的一个字段，是一个Runnable对象， * 当通过handler.post方法发送一个runnable的时候就会被封装到这个msg中 */ handleCallback(msg); /* * 此方法是Handler中的一个静态方法，方法体：message.callback.run(); * 只有这一句，可以看出是直接调用的run()方法，没有新建线程， * 否则也不符合这里线程通信了。 */ } else { if (mCallback != null) { // mCallback就是上面接口的对象 if (mCallback.handleMessage(msg)) { /* * 如果返回true直接return结束方法， * 不再调用handler中的handleMessage方法。 */ return; } } handleMessage(msg);// handler中的消息处理方法 } }
三、其他的相关问题
-
一个线程几个 Looper，几个 Handler，Looper 如何确定是哪个 Handler？
一个线程只有一个Looper来处理MessageQueue中的消息；Handler可以有多个，用来发送及处理消息。Looper不需要确定是那个Handler发送过来的消息，因为Message有个targ字段封装了发送他的handler,系统直接通过message.getTarg().hanldMessage();就可以调用到handler的处理消息方法。
-
两个均不是主线的线程如何用Handler通信
在阐述这个问题时难免又要回到Handler的机制说明上；线程间的通信关键是Handler的创建，而Handler的创建本质需要一个Looper对象的存在。
Android默认在主线程中初始化了一个Looper（详见
android.app.ActivityThread->Looper.prepareMainLooper()），其他线程都需要自己手动创建Looper；一个线程能够使用Handler处理消息，是必须要有Looper和MessageQueue的。下面回到具体问题，两个都不是主线程的线程需要通过Handler通信改如何操作？根据上面的分析我们知道：
- 需要在处理逻辑的线程Thread1创建Looper，有了Looper之后才能创建Handler；
- 之后在需要发消息的线程Thread2使用Thread1的handler对象发送Message；
有了理论，之后撸一把代码：
public class MainActivity extends ComponentActivity { private static final String TAG = "MainActivity"; private Looper looper2; private Thread1 thread1; private Thread thread2; private Handler child1Handler, child2Handler; @Override protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); initView(); } private void initView() { setContentView(R.layout.activity_main); thread1 = new Thread1("ChildThread1"); thread2 = new Thread2("ChildThread2"); thread1.start(); thread2.start(); } private void initHandler() { child1Handler = new Handler(thread1.getLooper()) { @Override public void handleMessage(@NonNull Message msg) { String ms = (String) msg.obj; Log.e(TAG, "当前线程：" + Thread.currentThread().getName() + " 消息：" + ms); try { Thread.sleep(1500); } catch (InterruptedException e) { e.printStackTrace(); } Message message = Message.obtain(); message.obj = "你好,我是" + Thread.currentThread().getName() + "!"; child2Handler.sendMessage(message); } }; child2Handler = new Handler(looper2) { @Override public void handleMessage(@NonNull Message msg) { String ms = (String) msg.obj; Log.w(TAG, "当前线程：" + Thread.currentThread().getName() + " 消息：" + ms); try { Thread.sleep(1500); } catch (InterruptedException e) { e.printStackTrace(); } Message message = Message.obtain(); message.obj = "你好,我是" + Thread.currentThread().getName() + "!"; child1Handler.sendMessage(message); } }; } class Thread1 extends HandlerThread { public Thread1(String name) { super(name); } } class Thread2 extends Thread { public Thread2(String name) { super(name); } @Override public void run() { Looper.prepare(); looper2 = Looper.myLooper(); initHandler(); Message message = Message.obtain(); message.obj = "你好,我是" + Thread.currentThread().getName() + "!"; child2Handler.sendMessage(message); Looper.loop(); } } }
四、Handler的内存泄露
Handler是引发内存泄露的大户，其根源还是在于Handler机制的设计结构上；
-
原因：
Message对象必须持有一个Handler的引用才能顺利分发任务。而如果Message在MessageQueue中不能及时被取出执行，则会导致MessageQueue长时间的持有Message对象；一般情况下我们会在Activity中以内部类的形式创建Handler；这就导致了一系列的连锁反应：Activity 被 Handler持有，Handler被Message持有，Message被MessageQueue持有，MessageQueue中任务积压，或者是本来就是个延时任务；这就导致了内存溢出。
-
解决办法：
根据上述的原因我们只需要能在Handler和Activity之间断开联系，既能保证内存不再泄露；
1）内部类是在类对象创建后作为对象的一个成员存在的，而静态内部类则是在类class文件加载时就创建了，不再与外部类对象关联；因此我们可以将handler声明为静态内部类。
2）我们都知道Hander还有个内部接口
Callback和与之对应的构造函数Handler(Callback callback)；/** * 实现回调弱引用的Handler * 防止由于内部持有导致的内存泄露 * 传入的Callback不能使用匿名实现的变量，必须与使用这个Handle的对象的生命周期一致， * 否则会被立即释放掉了 */ public class WeakRefHandler extends Handler { private WeakReference<Callback> mWeakReference; public WeakRefHandler(Callback callback) { mWeakReference = new WeakReference<Handler.Callback>(callback); } public WeakRefHandler(Callback callback, Looper looper) { super(looper); mWeakReference = new WeakReference<Handler.Callback>(callback); } @Override public void handleMessage(Message msg) { if (mWeakReference != null && mWeakReference.get() != null) { Callback callback = mWeakReference.get(); callback.handleMessage(msg); } } }接下来就是使用，由于是弱引用，当该类需要被回收时，就可以直接被回收掉：
private Handler.Callback mCallback = new Handler.Callback() { @Override public boolean handleMessage(Message msg) { switch(msg.what){ return true; } }; private Handler mHandler = new WeakRefHandler(mCallback);
