本文详细阐述了Android系统中的消息机制Handler的工作原理，包括Message、MessageQueue、Looper和Handler之间的交互流程。从代码层面深入分析了如何创建、传递、接收和处理消息，以及Handler在不同场景下的应用。通过实例代码跟踪整个流程，揭示了Looper对象与当前线程绑定的过程，最终实现了消息的高效分发和处理。
说明：以下内容只是本人个人的总结，由于能力有限，对Android机制研究不深，所以本文主要是从framework层对handler大致流程的一个梳理，如有错误的地方，欢迎指正，谢谢！
提到handler机制，必须要提到几个相关类，Message(Runnable)、MessageQueue、Looper、Handler。
Message(Runnable):消息实体，存放消息的内容。Runnable也可以被转换成Message后进行传递。
MessageQueue:消息队列，存放该线程中要传递的Message。
Looper：不断地从MessageQueue中取出Message，然后交给对应的handler处理。
Handler：主要有两个作用：将封住好的Message发送给MessageQue；处理Looper分发的Message。
首先通过一个关系简图来简单描述以下它们之间的关系。
由上图可以了解handler的大致原理。即
（1）开发者首先实例化一个handler对象，并重写handleMessage方法。
（2）获得Message实体，将要传递的数据封装进去，由handler将Message压入MessageQueue中。
（3）Looper不断地检测MessageQueue中是否有Message，如果有取出后将其分发给对应的handler。
（4）handler调用handleMessage方法取出Message后，进行相应地处理。
以上是一个简单地流程描述，下面通过代码来详细的介绍：
一、首先把涉及到的类中一些主要字段方法介绍一下：
(1)Message源码路径：frameworks/base/core/java/android/os/Message.java
public final class Message implements Parcelable {
public int what;//在handler的handleMessage方法中根据该值区分不同的Message，进行不同的处理
public Object obj;//该类型是Object，所以可以设置为不同类型的数据实体
Bundle data; //通过bundle来封住数据
Handler target;//用于决定提交给哪个的handler来处理。后面代码中说明
Runnable callback;//存放Runnable类型
public static Message obtain() ;//获得一个Message实例
}(2)MessageQueue源码路径：frameworks/base/core/java/android/os/MessageQueue.java
public final class MessageQueue {
boolean enqueueMessage(Message msg, long when) ;//将msg压入队列
Message next() ;//将Message出队
void removeMessages(Handler h, int what, Object object);//移除队列中的元素
}(3)Looper源码路径：frameworks/base/core/java/android/os/Looper.java
public final class Looper {
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();//将looper对象与当前线程绑定
private static Looper sMainLooper; // 主looper
final MessageQueue mQueue; //每个Looper对应一个MessageQueue对象
//下面几个方面的作用在后面代码中介绍
public static void prepare() ;
private static void prepare(boolean quitAllowed) ;
public static void loop() ;
public static void prepareMainLooper() ;
}(4)Handler源码路径：frameworks/base/core/java/android/os/Handler.java
public class Handler {
public Handler() ;//构造方法
public Handler(Callback callback, boolean async);//构造方法
public final Looper getLooper() ;//获得当前线程对应的Looper
public void handleMessage(Message msg) ; //处理Looper分发的msg
public void dispatchMessage(Message msg) ; //根据msg.target分发给对应的handler
public final boolean post(Runnable r);//将Runnable包装成Message压入队列中
public final boolean sendMessage(Message msg)；//将Message压入队列中
public boolean sendMessageAtTime(Message msg, long uptimeMillis);//将Message压入队列中
…… //还有很多重载的方法 不一一列出了
}二、根据上面的步骤代码跟踪整个流程：
(1)开发者首先实例化一个handler对象，如：
private Handler handler = new Handler(){
public void handleMessage(Message msg){
switch(msg.what){
……
}
}
}
//handler实例化调用构造函数：
public class Handler {
public Handler() {
this(null, false);
}
public Handler(Callback callback, boolean async) {
mLooper = **Looper.myLooper()**;//获得与当前线程绑定的Looper对象
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = **mLooper.mQueue**;//取出Looper中的MessageQueue
mCallback = callback;
mAsynchronous = async;
}
}
public final class Looper {
public static Looper myLooper() {
return **sThreadLocal.get()**;//获得与当前线程绑定的Looper对象
}
public static MessageQueue myQueue() {
return **myLooper().mQueue**;//获得Looper中的MessageQueue
}
} 这里可能有个疑问：Looper对象是在什么时候与当前线程绑定的？这个在后面介绍。
(2)开发者首先获得一个Message实体，设置相应的字段，要传递的数据。比如：
private final static int LOAD_FINISH = 0;
Person person = new Person();//需要传递的实体
Message msg = Message.obtain()；//android系统维护一个全局的Message池，也可以自己new
msg.what = LOAD_FINISH;//任意一个整数 最好设置成静态常量
msg.obj = person;//封装需要传递的实体
handler.sendMessage(msg);//将msg压入MessageQueue中
//调用sendMessage后的内部实现：
public class Handler {
public final boolean sendMessage(Message msg){
return **sendMessageDelayed**(msg, 0);
}
public final boolean sendMessageDelayed(Message msg, long delayMillis){
if (delayMillis < 0) {
delayMillis = 0;
}
return **sendMessageAtTime**(msg, SystemClock.uptimeMillis() + delayMillis);
}
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;//为当前线程中绑定的Looper中取出来的MessageQueue
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
return **enqueueMessage**(queue, msg, uptimeMillis);
}
private boolean More ...enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;//在Looper分发消息时根据target来决定分发给哪个Handler处理
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return **queue.enqueueMessage**(msg, uptimeMillis);//压入消息队列中
}
}
//如果是要传递Runnable对象
public final boolean post(Runnable r){
return sendMessageDelayed(**getPostMessage(r)**, 0);
}
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
**m.callback = r**;//设置m的callback字段为Runnable对象
return m;
}（3）Looper不断地检测MessageQueue中是否有Message，如果有取出后将其分发给对应的handler。
public final class Looper {
public static void loop() {
final Looper me = myLooper();//获得当前线程绑定的Looper
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;//获得Looper中的MessageQueue
for (;;) {//一个死循环 不断地取出msg 分发给对应的handler处理
Message msg = **queue.next()**; // 从MessageQueue中依次取出msg
if (msg == null) {
return;
}
**msg.target.dispatchMessage**(msg);//msg.target为handler实例，这里根据前面设置的target 决定分发给哪个handler处理
}
}
}（4）handler调用handleMessage方法取出Message后，进行相应地处理。
public class Handler {
public void dispatchMessage(Message msg) {
if (msg.callback != null) {//说明msg封装了Runnable对象
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
**handleMessage**(msg);//此处调用前面重写的handleMessage方法处理
}
}
private static void handleCallback(Message message) {
message.callback.run();//调用Runnable中run方法
}
}三、以上只是将handler机制单独出来分析了一下大致流程，并且留了一个疑问：Looper对象是在什么时候与当前线程绑定的？下面结合应用的启动过程来解决这个疑问！
应用启动时，由ZygoteInit启动主线程，主线程对应ActivityThread类，经一系列调用才会去执行Activity的onCreate方法。
frameworks/base/core/java/android/app/ActivityThread.java
public final class ActivityThread {
final H mH = new H();//handler对象，供主线程使用
public static void main(String[] args) {
**Looper.prepareMainLooper()**;//只有主线程才能调用
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();//系统内部定义的handler 供主线程使用
}
**Looper.loop()**;//在该方法中不断循环取出message
throw new RuntimeException("Main thread loop unexpectedly exited");
}
}
final Handler getHandler() {
return mH;
}
}
public final class Looper {
public static void prepareMainLooper() {
**prepare(false)**;//参数false表示该线程不允许退出
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();//获得创建的Looper
}
}
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
**sThreadLocal.set(new Looper(quitAllowed))**;//在这里创建一个Looper实例，然后与主线程绑定
}
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);//创建了一个MessageQueue实例
mThread = Thread.currentThread();
}
}总结：在启动主线程时，通过prepareMainLooper方法调用prepare方法创建looper并与主线程绑定，同时创建一个MessageQueue供looper使用。在主线程中，我们自定义handler，并通过handler将Message压入主线程的looper对应的MessageQueue中，looper再不断循环从MessageQueue中取出Message根据target字段决定分发给哪个handler处理，handler在handleMessage方法中得到Message，取出其中包含的数据进行相关处理。
以上的分析只是停留在framework层，更底层的就涉及到Ibinder通信了。个人还无法清除的分析出来。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
