本人今年参加了很多面试，也有幸拿到了一些大厂的offer，整理了众多面试资料，后续还会分享众多面试资料。
整理成了面试系列，由于时间有限，每天整理一点，后续会陆续分享出来，感兴趣的朋友可关注+收藏

Handler机制主要包括：MessageQueue、Looper、Handler以及Message四个部分。
· Message: 传递的消息及数据
· MessageQueue: 消息队列，但是它的内部并不是用的队列实现的，而是通过单链表实现的，因为单链表在插入和删除上更有优势，主要功能是向消息池投递消息（MessageQueue.enqueueMessage）和从消息池取走消息（MessageQueue.next）.
· Handler: 消息辅助类，主要功能是向消息池发送各种消息（Handler.sendMessage）和处理相应的消息事件（handler.handleMessage()）。
· Looper：消息控制器，不断循环执行（Looper.loop）,从MessageQueue中读取消息，按分发机制将消息分发给目标处理者。

1. MessageQueue、Looper和Handler之间的关系：

（1）每个线程只有一个Looper，Looper是保存在ThreadLocal中的。主线程已经创建了一个Looper了，所以不需要创建Looper,如果是其他线程，就需要创建Looper；
（2）每个线程中可以有多个Handler,即一个Looper可以处理来自多个Handler的消息。怎样区分message来自哪个Handler？message上面有个属性是target，这个target就会标识Handler.
（3）Looper中维护一个MessageQueue,MessageQueue中的message来自不同的Handler.

2. Handler运行机制：

在子线程执行完耗时操作，当Handler发送消息时，将会调用 MessageQueue.enqueueMessage，向消息队列中添加消息。 当通过 Looper.loop开启循环后，会不断地从消息池中读取消息，即调用 MessageQueue.next， 然后调用目标Handler（即发送该消息的Handler）的 dispatchMessage方法传递消息， 然后返回到Handler所在线程，目标Handler收到消息，调用 handleMessage方法，接收消息，处理消息。

3. Handler机制详解

3.1 子线程到主线程通信方式有哪些？子线程到主线程通信的原理？

子线程到主线程的通信方式有：Rxjava、eventBus和Handler，但底层原理都是通过Handler来实现的。
通信原理：
子线程将消息送入队列：handler.sendMessage(msg) -> messagesQueue.enqueueMessage()

主线程：main()-> looper.loop() -> MessageQueue.next() -> handler.dispatchMessage-> handler.handleMessage()。

主线程中开启后，就会一直执行looper.loop()，不断的同MessageQueue中获取消息并通过msg上的target标志分发到对应的Handler去。

其本质是是通过内存共享的方式，MessageQueue就像是那个共享的内存。

3.2 Handler内存泄露的原因？

可参考：http://t.csdn.cn/gVsNw
当使用内部类来创建Handler时，handler对象会隐式地持有一个外部类对象（通常是一个Activity）的引用（这是JAVA的特性）。而Handler通常会伴随着一个耗时的后台线程（例如从网络拉取图片）一起出现，这个后台线程在任务执行完毕（例如图片下载完毕）之后，通过消息机制通知Handler，然后Handler把图片更新到界面。然而，如果用户在网络请求过程中关闭了Activity，正常情况下，Activity不再被使用，它就有可能在GC检查时被回收掉，但由于这时线程尚未执行完，而该线程持有Handler的引用（不然它怎么发消息给Handler？），这个Handler又持有Activity的引用，就导致该Activity无法被回收（即内存泄露），直到网络请求结束。

1）那为什么不会被回收呢？可以分析分析引用链：
Handler -> Activity： handler持有activity的引用
那么谁持有hander的引用呢？源码中有msg.target=handler, 所以：msg->handler;
而messageQueue持有msg的引用，即：messageQueue -> msg;
Lopper持有MessageQueue，Looper -> messageQueue
那么谁持有Looper的引用呢？从源码得知，sThreadLocal->Looper,
而sThreadLocal是new的一个静态变量，可以进行作为GC root，所以整个引用链：
sThreadLocal->Looper->messageQueue->msg->hander->activity.
而sThreadLocal是GCroot，所以整个链都在GCroot上，不会被回收，所以出现上面那种情况时，就出现了内存泄露。

2) 怎样解决Handler导致的内存泄露？
方法1：静态内部类+弱引用

1.static class MyHandler extends Handler {
2.    WeakReference<Activity > mActivityReference;
3.    MyHandler(Activity activity) {
4.        mActivityReference= new WeakReference<Activity>(activity);
5.    }
6.    @Override
7.    public void handleMessage(Message msg) {
8.        final Activity activity = mActivityReference.get();
9.        if (activity != null) {
10.            //...
11.        }
12.    }
13.}

将 Handler 声明为静态内部类，Handler 也就不再持有 Activity 的引用，所以 Activity 可以随便被回收。但Handler 不再持有 Activity 的引用，导致 Handler 无法操作 Activity 中对象，所以可以在 Handler 中添加一个对 Activity 的弱引用（WeakReference）。

方法2：程序逻辑保护
在 Activity 被销毁时及时清除消息，从而及时回收 msg和handler,使用removeMessage()和判断mHandler来继续移除msg和handler，避免内存泄漏问题。如：

1.@Override
2.protected void onDestroy() {
3.    super.onDestroy();
4.    if (mHandler != null)  {
5.        mHandler.removeCallbacksAndMessages(null);
6.    }
7.}

3.3 MessageQueue中存储的Msg数量有上限吗？为什么？能不能用阻塞队列做MessageQueue?

MessageQueue没有上限。原因如下：
· 从代码的角度，主线程中的looper.loop()是写的一个死循环，如果有上限，在入队和出队时肯定会做额外判断，然而并没有，所以是没有上限。

· 从应用分析的角度：如下图，从handler源码可以看出，AMS对activity、Service等和管理，以及activity对fragment的管理都是转换为msg，然后使用handler完成的。我们无法判断出用户会开启多少fragemnt、activity，所以是不会设置上限的。

不能使用阻塞队列，阻塞队列是在队列达到上限或下限后进行阻塞，而这没有上限，所以不能使用阻塞队列。

3.4 Handler如何处理发送延迟消息的？

消息入队阶段：消息队列是一个单向链表，会根据执行时间进行排序；由源码可知，在使用sendMessageDelayed(msg, delayMillis)时，会添加一个延迟时间，其源码如下：

而MessageQueue会根据时间进行排序，如下所示：

在取出消息的执行阶段：每次都会从链表表头去消息，每次取出消息的会判断当前时间是否小于Msg的执行时间，如果小于，则调用一个native函数nextPollTimeoutMills()进行延迟等待。如果大于，则说明到了执行时间，则进行之后的操作。其源码如下:

3.5 使用Message时应该如何创建它？

尽量不要通过new Message的方式， 可以通过如下方式创建：

1.Message message = myHandler.obtainMessage();  //通过 Handler 实例获取，底层也是调用的Message.obtain()
2.Message message1 = Message.obtain();          //通过 Message 获取

原因如下：
系统维护了一个消息池，每次用完的消息并不会直接将消息销毁，而是将内存全部置空，然后放到消息池去。

这样的好处就是为了避免”内存抖动“从而导致OOM和卡顿，因为内存抖动就是频繁的申请内存和释放内存。系统会处理大量的消息，如果都使用new的方式，就会造成内存抖动。

3.6 Handler没有消息处理时，会阻塞吗？阻塞后为什么不会产生ANR?

会发生阻塞，但不会产生ANR。
因为ANR是由于超时了，才会ANR。其超时阈值如下：

3.7 如何在子线程中创建handler?

在子线程中创建handler，需要创建Looper(主线程中不用创建是因为启动时就创建好了)，所以可以继承Thread类，里面定义好Looper的创建。

没有消息时， looper也会一直轮询。