由Handler提出的问题图

一、提出问题

面试时常被问到的问题：

简述 Android 消息机制

Android 中 Handler，Looper，MessageQueue，Message 有什么关系？

这俩问题其实是一个问题，其实只要搞清楚了 Handler，Looper，MessageQueue，Message 的作用和联系，就理解了 Android 的 Handler 消息机制。那么再具体一点：

为什么在主线程可以直接使用 Handler？

Looper 对象是如何绑定 MessageQueue 的？

MessageQueue 里的消息从哪里来？Handler是如何往MessageQueue中插入消息的？

Message 是如何绑定 Handler 的？

Handler 如何绑定 MessageQueue？

关于 handler，在任何地方 new handler 都是什么线程下？

Looper 循环拿到消息后怎么处理？

二、解决问题

从主消息的消息机制开始分析

1.1 主线程Looper的创建和循环

Android应用程序的入口是main函数,主线程Looper的创建也是在这里完成的.

ActivityThread ---> main()函数

代码图

Looper.prepareMainLooper():用来创建主线程的Looper对象

1.1.1 创建主线程Looper

looper ---> prepareMainLooper()

 looper ---> prepareMainLooper()

prepareMainLooper()方法:主要是使用prepare(false)创建当前线程的Looper对象,再使用myLooper()方法来获取当前线程的Looper对象.

// step1 Looper() ---> prepare()

Looper() ---> prepare()

prepare()方法中用ThreadLocal来保存主线程的Looper对象.

ThreadLocal:用来存储数据的类,存放属于当前线程的变量

ThreadLocal提供了get/set方法分别用来获取和保存变量.   比如主线程通过prepare()方法来创建Looper对象,并使用sThreadLocal.set(new Looper(quitAllowed))来保存主线程的Looper对象.那么主线程调用myLooper()[实际上是调用了sThreadLocal.get方法].通过ThreadLocal来获取主线程的Looper对象.

如果在子线程调用这些方法就是通过ThreadLocal保存和获取属于子线程的Looper对象

// step2: Looper ---> myLooper()

Looper ---> myLooper()

myLooper()方法 == ThreadLocal.get()方法 获取当前线程ThreadLocal保存的Looper对象

附加问题

问题一：为什么在主线程可以直接使用Handler？

主线程已经创建了Looper对象并开启了消息循环

问题二:Looper对象是如何绑定MessageQueue的/Looper对象创建MessageQueue的过程

Looper有一个成员变量Queue,它就是Looper对象默认保存的MessageQueue.

上述代码中Looper自带一个构造器,新建Looper对象时会直接创建MessageQueue并且赋值给Queue.

1.1.2 开始循环处理消息

回到最开始的main()函数,在创建了Looper对象以后就调用了Looper.loop()来循环处理消息

Looper.loop()

Looper ---> loop()

Looper ---> loop()

step1:myLooper():获取当前线程的对象[ ThreadLocal在哪个线程使用就获取哪个线程的Lopper对象]

step2:me.mQueue: Looper对象创建时新建的MessageQueue变量

step3: 一个for循环,首先通过 queue.next() 来提取下一条消息

step4:msg.target.dispatchMessage(msg) 这个方法最终会调用 Handler的handlerMessage(msg)方法

附加问题

msg.target是何时被赋值的/Messge是如何绑定Handler的? (那我们来看看dispatchMessage()这个方法)

dispatchMessage()

可以看到最后执行了handlerMessage()方法 这是一个空方法也就是需要我们覆写并实现的

dispatchMessage附加问题

消息分发的优先级

    ·Message的回调方法:message.callback.run()优先级最高;

    ·Handler的回调方法:mCallback.handleMessage(msg)优先级次于上方;

    ·Handler的回调方法:handleMessage()优先级最低;

Looper循环通过Handler发送消息一个整体的流程.接下来分析Handler在消息机制中的主要作用以及和Looper、Message的关系.

---

1.2 Handler的创建和作用

上面说到loop()方法不断从消息队列MessageQueue中取出消息(queue.next()方法),如果没有消息则阻塞,反之交给Message绑定的Handler处理

需要解决的问题

    · MessageQueue里的消息从哪里来的?

    · Handler是如何往MessageQueue中插入消息的?

    · " msg.target "是何时被赋值的?/Message是如何绑定Handler的?

---

1.2.1 Handler发送消息

Handler ---> sendMessage(Message msg)

Handler ---> sendMessage(Message msg)

可以看到sendMessage(Message msg) 方法最终会调用enqueueMessage()方法,这个方法主要有两个作用

            1> 赋值Message对象的target

                    msg.target = this 把发送消息的Handler赋值给msg的target.

            2> 消息队列插入消息

                    queue.enqueueMessage(msg,uptimeMillis) queue是MessageQueue的一个实例

                    queue.enqueueMessage(msg,uptimeMillis) 是执行 MessageQueue的enqueueMessage方法来插入消息

---

1.2.2 Handler的创建

下面是Handler无参构造器和主要构造器,另外几个重载的构造器是有些通过传递不同的参数调用包含两个参数的构造器

两个参数构造器的第一个参数为callback回调,第二个函数用来标记消息是否异步

handler构造代码图

step1: 调用myLooper()方法,该方法是使用sThreadLocal对象获取当前线程的Looper对象

回顾图

如果获取的Looper对象为NULL,说明没有执行Looper.prepare()为当前线程保存Looper变量,就会抛出RuntimeException异常.

这里又说明了Handler必须再有Looper的线程中使用.报错先放一边,没有Looper就无法绑定MessageQueue对象也就无法进行更多有关操作

step2: mQueue = mLooper.mQueue; 说明了 Handler的MessageQueue对象是由当线程Looper的MessageQueue赋值.

由于Handler和Looper可以看作使用的是一个HandlerMessageQueue对象,所以Handler和Looper共享消息队列MessageQueue.

            ·Handler发送消息(用mQueue往消息队列插入消息)

            ·Looper可以方便的循环使用mQueue查询消息.如果查询到消息,就可以用Message对象绑定的Handlertarget去处理消息,反之则阻塞.

补充问题

关于handler,在任何地方new handler都是什么线程下?（这个问题要分是否传递Looper对象来看）

        ·传递Looper对象创建Handler: Handler handler = new Handler(looper); 

传递Looper对象创建Handler

    ·不传递 Looper 创建 Handler：Handler handler = new Handler() 上文就是 Handler 无参创建的源码，可以看到是通过 Looper.myLooper() 来获取 Looper 对象，也就是说对于不传递 Looper 对象的情况下，在哪个线程创建 Handler 默认获取的就是该线程的 Looper 对象，那么 Handler 的一系列操作都是在该线程进行的。

---

可以看出来传递Looper对象Handler就直接使用了.所以对于传递Looper对象创建Handler的情况下,传递的Looper是哪个线程的,Handler绑定的就是该线程

到这里Looper和Handler就有应该大概的流程了,我们看一下应该简单的子线程Handler的使用例子

子线程Handler的使用例子

step1:调用Looper.prepare() 为当前线程创建Looper对象,同时也就创建了MessageQueue对象[创建Looper对象的同时,Looper会自带MessageQueue对象]。之后将该线程的Looper对象保存在ThreadLocal中.注意这里的一切操作都在子线程中完成,如果不调用Looper.prepare方法就会导致Handler报错.

---

step2:Handler handler = new Handler() 创建Handler对象,覆写handlerMessage处理消息,等待该Handler发送的消息处理时会调用该方法.

---

step3:handler.sendEmpteMessage(1) 使用handler发送消息,这里只是单例. 发送的过程中会将自己赋值给msg.target,然后再将消息插入到Looper绑定的MessageQueue()中;

---

step4:Looper.loop() 首先获取当前线程的Looper,根据Looper对象可以拿到Looper保存在MessageQueue中的对象mQueue.有了MessageQueue对象就可以for循环它保存的消息Message对象,如果没有消息就返回null导致阻塞. 然后用Message中保存的Handler:msg.target来处理消息,最终调用handlerMessage覆写的方法来处理消息

---

step5:Looper.myLooper.quit() 逻辑处理完毕后,需要调用quit方法来终止消息循环,否则这个子线程就会一直处于等待状态,而如果子线程处于等待状态退出Looper以后,这个线程就会被立刻终止。[因此建议不需要使用Handler的时候终止Looper]

---

三、总结和其他小知识点

2.1 Handler、Looper、MessageQueue、Message

    ·Handler用来发送消息,创建时先获取默认或传递来的Looper对象,并持有Looper对象包含的MessageQueue对象,发送消息的时候该MessageQueue对象来插入消息并把自己封装到具体的Message中;

    ·Looper用来为某个线程作消息循环,.Looper持有一个MessageQueue对象mQueue,这样就可以通过循环来获取MessageQueue所维护的Message.如果获取MessageQueue没有消息时,便阻塞Loop的queue.next()中的nativePollOnce()方法,随后唤起主线程继续工作,之后便用Message封装的handler对象进行处理.

    ·MessageQueue是一个消息队列.他不直接添加消息,而是通过Looper关联的Handler对象来添加消息.

    ·Message包含了要传递的数据和信息

---

2.2.1 Android中为什么主线程不会因为Looper.loop()里的死循环卡死?

(简单做法就是可执行代码是一直能执行下去的,死循环便能保证不会被退出) 通过创建新线程的方式

为这个死循环准备了一个新的线程（在进入死循环之前便创建了新的binder[Binder详细讲解]线程,在代码ActivityThread.main()中）

通过binder创建新线程

thread.attach(false):创建一个Binder线程[具体是指ApplicationThread,Binder的服务器,用于接收系统服务AMS发送来的事件]该binder线程通过Handler将Message发送给主线程

---

主线程的死循环一直运行是不是特别消耗CPU资源呢?

其实不是的,这里涉及到Linux pipeLinux pipe详细教学/epoll机制Epoll机制详细教学（Linux pipe与Epoll的区别）.简单的说在主线程的MessageQueue没有消息时,便阻塞loop的quque.next().所以说大多数时候都处于休眠状态,并不会消耗大量CPU资源.

---

Activity的生命周期是怎么实现在死循环体外能够执行起来的?

函数有一部分获取sMainThreadHandler的代码

类H继承了Handler,在主线程创建时就创建了Handler用于处理Binder线程发送来的消息

Activity的生命周期都是依靠主线程的Looper.loop，当收到不同Message时则采用相应措施：

在H.handleMessage(msg)方法中，根据接收到不同的msg，执行相应的生命周期。

比如收到msg=H.LAUNCH_ACTIVITY，则调用ActivityThread.handleLaunchActivity()方法，最终会通过反射机制，创建Activity实例，然后再执行Activity.onCreate()等方法；

再比如收到msg=H.PAUSE_ACTIVITY，则调用ActivityThread.handlePauseActivity()方法，最终会执行Activity.onPause()等方法。 上述过程，我只挑核心逻辑讲，真正该过程远比这复杂。

---

3.3 Handler使用造成内存泄漏

         · 有延时消息,要在Activity销毁的时候移除Messages

         · 匿名内部类导致的泄漏改为匿名静态内部类,并且对上下文或者Activity使用弱引用

---

4.1Handler原理

handler的构造方法内部通过Looper.myLooper创建一个Looper,然后通过Looper去创建一个消息队列

这个时候的handler,looper与messagequeue就捆绑到一起了这个时候SendEmptyMessage()与sendEmptyMessageDelayed()最终都会到enqueueMessage()方法当中.

这个方法是将发送的消息添加到消息队列中.在这个方法中会把当前的handler对象绑定到message当中的一个target变量中.这样就完成了handler向消息队列存放消息的过程.

工作原理流程图

4.2 Handler的应用场景

因为Android中,主线程不建议做耗时操作,子线程不建议更新UI.

但Android开发其实就是搭建好页面,将服务器的数据展示到页面上.所以网络请求会使用的很频繁

而网络请求属于耗时操作,需要放到子线程中完成.

但一般情况下也不会通过子线程更新UI.需要将请求成功的数据发送到主线程进行UI更新

所以一般使用handler

4.3 ThreadLocal

1>定义:ThreadLocal是线程内部的数据存储类

---

4.4 HandlerThread

1>定义：是一个Android已经封装好的轻量级异步类

2>作用: 实现多线程/异步通信、消息传递

3>优点:方便实现异步通信

---

4.5 内部原理=Thread类+Handler机制

---

加油加油加油

补充:

Looper:轮询消息,获取到消息后发送给Handler

    a.取消息

    b.消息给到Handler

  përpare() 初始化Looper,只有一个

  Looper() 构造 初始化了消息队列

  loop() 轮询方法(取消息 将消息给到handler）

Handler

    a.发消息

    b.处理消息

创建Handler保证当前线程持有Looper对象

sendMessage() 这个方法最终会走enqueueMessage()方法 在这个方法中会把当前的handler对象绑定到message当中的一个target变量中.这样就完成了handler向消息队列存放消息的过程.

MessageQueue

    存储消息(排队)

Message        

    数据的载体

ThreadLocal

    一个存储线程对象的容器

口述

首先我们Handler内部构造通过Looper.myLooper创建了一个Looper对象,Looper对象自己携带构造器创建了MessageQueue对象,这样Handler、Looper、MessageQueue绑定到了一起 Looper:它是用来轮询消息,获取到消息交给Handler Handler呢负责发送消息 处理消息 MessageQueue:是一个存储消息的队列.我们先走到Looper里面的përpare()方法这个方法只能调用一次,它是用来创建Looper对象的,在这个方法里面有一个ThreadLocal对象,它是用来存储Looper对象的.用这个方法来保证一个线程只能有一个Looper实例.然后我们看一下Looper的构造,里面初始化了MessageQueue对象并且保存了当前线程.消息是如何传进Handler里面的 看一下Loop.loop() 首先里面先调用了一个myLooper() 它把我们刚开始通过përpare()方法创建的Looper对象取了出来 如果为Looper为空则抛出异常 Looper不为空的话将messageQueue对象获取 进行死循环遍历 通过queue.next()方法取出来消息 如果消息为null则返回如果消息不为空的话调用msg.target.dispatchMessage(msg)方法这个方法就是将消息传递给handler的[target就是handler的一个对象] 在dispatchMessage()这个方法 通过他处理消息 这个方法里面可以看到 当mag的callBack对象是null的时候它会走一个handleMessage(Message msg) 是一个空方法需要我们覆写  我们Handler通过sendMessage()这个方法发送消息 随后走到SendEmptyMessage()与sendEmptyMessageDelayed() 这两个方法最终调用 enqueueMessage()这个方法 它会通过 msg.target =this; 把发送消息的Handler赋值给msg的target. 这样就完成了handler向消息队列存放消息的过程

为什么主线程不需要调用Looper.prepare()？ 因为系统已经帮我们创建过了