android机制和java一样_Android的消息机制(java层)

前言

Android的消息机制用于同进程的线程间通信，它是由MessageQueue，Message，Looper，Handler共同组成，Android中大量的交互都是通过消息机制，比如四大组件启动过程与服务的交互、View的绘制、更新等都离不开消息机制，所以Android在某种意义上也可以说成是一个以消息驱动的系统，在Android中消息机制的运作分为java层和native层，它们之间的运作机制不一样，本文讲解的是java层的消息机制，如果你想了解native层的消息机制，可以阅读：

但其实java层的消息机制的核心功能都交给了native层的消息机制来完成，但作为应用开发，首先要掌握java层的消息机制。

本文源码基于Android8.0，源码相关位置:

frameworks/base/core/java/android/os/*.java (*代表MessageQueue、Handler、Looper、Message)

消息机制概述

Android应用的每个事件都会转化为一个系统消息即Message，消息中包含了事件的相关信息和消息的处理人即Handler，消息要通过Handler发送，最终被投递到一个消息队列中即MessageQueue，它维护了一个待处理的消息列表，然后通过Looper开启了一个消息循环不断地从这个队列中取出消息，当从消息队列取出一个消息后，Looper根据消息的处理人(target)将此消息分发给相应的Handle处理，整个过程如下图所示。

它们的工作原理就像工厂的生产线，Looper是发动机，MessageQueue是传送带，Handler是工人，Message则是待处理的产品。

java层消息机制架构图

handler2.png

Looper --- 是每个线程的MessageQueue管家，里面有一个MessageQueue消息队列，负责把消息从MessageQueue中取出并把消息传递到Handler中去，每个线程只有一个Looper；

MessageQueue --- 消息队列，有一组待处理的Message，主要用于存放所有通过Handler发送的消息，每个线程只有一个MessageQueue；

Message --- 是线程之间传递的消息，里面有一个用于处理消息的Handler；

Handler --- 主要用于发送和处理消息，里面有Looper和MessageQueue。

简单使用

在开发中，我们在子线程中执行完操作后通常需要更新UI，但我们都知道不能在子线程中更新UI，此时我们就要通过Handler将一个消息post到UI线程中，然后再在Handler中的handleMessage方法中进行处理，如果我们不传递UI线程所属的Looper去创建Handler，那么该Handler必须在主线程中创建，如下：

//在主线程中创建Handler

Handler mHandler = new Handler(){

@Override

public void handleMessage(Message msg){

//更新UI

}

}

//在子线程中进行耗时操作

new Thread(){

public void run(){

mHandler.sendEmptyMessage(0);

}

}

以上就是我们平时使用Handler的常规用法了。

接下来我们以应用主线程(又叫做UI线程)的消息机制运作为例讲解Android消息机制的原理。

源码分析

1、 Looper的创建

我们知道Android应用程序的入口实际上是ActivityThread.main方法，而应用的消息循环也是在这个方法中创建，具体源码如下：

//ActivityThread.java

public static void main(String[] args) {

//...

//1、创建消息循环Looper

Looper.prepareMainLooper();

//...

//2、执行消息循环

Looper.loop();

}

我们关注注释1，ActivityThread调用了Looper的prepareMainLooper方法来创建Looper实例，Looper的prepareMainLooper方法如下：

//Looper.java

public static void prepareMainLooper() {

//1、创建不允许退出的Looper

prepare(false);

synchronized (Looper.class) {//保证只有一个线程执行

if (sMainLooper != null) {

throw new IllegalStateException("The main Looper has already been prepared.");

}

//2、将刚刚创建的Looper实例赋值给sMainLooper

//sMainLooper字段是Looper类中专门为UI线程保留的，只要某个线程调用了prepareMainLooper方法，把它创建的Looper实例赋值给sMainLooper，它就可以成为UI线程，prepareMainLooper方法只允许执行一次

sMainLooper = myLooper();

}

}

private static void prepare(boolean quitAllowed){//quitAllowed表示是否允许Looper运行时退出

//Looper.prepare()只能执行一次

if (sThreadLocal.get() != null) {

throw new RuntimeException("Only one Looper may be created per thread");

}

//把Looper保存到TLS中

sThreadLocal.set(new Looper(quitAllowed));

}

public static @Nullable Looper myLooper() {

//获取当前线程TLS区域的Looper

return sThreadLocal.get();

}

private static Looper sMainLooper; // guarded by Looper.class

static final ThreadLocal sThreadLocal = new ThreadLocal();

线程在调用prepareMainLooper方法后，就代表它成为了一个UI线程，可以看到prepareMainLooper方法中是调用Looper的prepare方法来创建Looper实例，当要获取创建的Looper实例时，是通过Looper的myLooper方法来获取的，在调用prepare方法时，会把创建的Looper实例set到ThreadLocal中，当获取时也会从ThreadLocal中通过get方法获取，那么ThreadLocal是什么？这里简单介绍一下ThreadLocal：

ThreadLocal：线程本地存储区(Thread Local Storage，简称为TLS)，每 个线程都有自己的私有的本地存储区域，不同线程之间彼此不能访问对方的TLS区域。

它的常用操作方法有：

ThreadLocal.set(T value)：将value存储到当前线程的TLS区域。

ThreadLocal.get()：获取当前线程TLS区域的数据

关于ThreadLocal更多信息可以查看ThreadLocal原理解析

ThreadLocal的get()和set()方法操作的类型都是泛型，我们从ThreadLocal在Looper中的定义可以看出，sThreadLocal的get()和set()操作的类型都是Looper类型, 所以，由于ThreadLocal的作用，每个线程只能保存一个Looper，不同线程的Looper是不相同的，这样，通过调用Looper.prepare(false)方法，UI线程中就保存了它对应的、唯一的Looper实例，当在UI线程调用Looper.myLooper方法时它就会返回UI线程关联的Looper实例，当然，如果你在子线程中想要获得UI线程关联的Looper实例，就需要调用getMainLooper方法，该方法如下：

public static Looper getMainLooper() {

synchronized (Looper.class) {

//返回UI线程的Looper实例

return sMainLooper;

}

}

以上就是UI线程的Looper的创建过程，执行ActivityThread.main后，应用程序就启动了，UI的消息循环也在Looper.loop方法中启动，此后Looper会一直从消息队列中取出消息，用户或系统通过Handler不断往消息队列中添加消息，这些消息不断的被取出，处理，回收，使得应用运转起来。

我们在平时开发时，一般是使用不带参数的prepare()方法来创建子线程对应的Looper实例，如下：

//我们平时使用的prepare方法

public static void prepare() {

//quitAllowed = true

prepare(true);

}

和UI线程的区别是，UI线程的Looper是不允许推出的，而我们的Looper一般是允许退出的。

2、MessageQueue的创建

我们在上面知道，调用Looper的prepare方法就会创建Looper实例，同时会把Looper实例通过ThreadLocal保存到线程中，在创建Looper时还会同时在构造中创建MessageQueue实例，如下：

//Looper.java

final MessageQueue mQueue;

//Looper唯一的构造函数

private Looper(boolean quitAllowed) {

//可以看到MessageQueue是在Looper中创建的

mQueue = new MessageQueue(quitAllowed);

mThread = Thread.currentThread();

}

Looper只有这一个构造函数，并且它是私有的，所以我们只能通过Looper的prepare方法创建Looper实例，由于ThreadLocal，每个线程最多只能对应一个Looper实例，而每个Looper内部只有一个MessageQueue实例，推出：每个线程最多对应一个MessageQueue实例。

我们看一下MessageQueue的构造，如下：

//MessageQueue.java

private long mPtr; // used by native code

MessageQueue(boolean quitAllowed) {

mQuitAllowed = quitAllowed;

//通过native方法初始化消息队列，其中mPtr是供native代码使用

mPtr = nativeInit();

}

MessageQueue的构造中会通过native方法在native层创建一个属于native层的消息队列NativeMessageQueue，然后把NativeMessageQueue的地址返回给java层保存在mPtr中，java层和native层之间的通信就通过这个mPtr指针。

MessageQueue是消息机制的核心类，它是java层和native层的连接纽带，它里面有大量的native方法，Android有俩套消息机制(java层和native层，实现不一样)，但本文只讲解java层的消息机制，不会涉及到native层.

我们通过Looper的myQueue方法就能获取到它关联的MessageQueue实例，如下：

//Looper.java

public static @NonNull MessageQueue myQueue() {

//先通过TLS获取Looper实例，再从对应的Looper中获取MessageQueue实例

return myLooper().mQueue;

}

3、消息循环的运行

在ActivityThread的mian方法在创建Looper后，通过Looper.loop方法就启动了消息循环，这个函数会不断的从MessageQueue中取出消息、处理消息，我们点进此方法看一下它的源码：

//Looper.java

public static void loop() {

final Looper me = myLooper();

if (me == null) {

throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");

}

//从Looper中取出MessageQueue

final MessageQueue queue = me.mQueue;

//...

for (;;) {

//1、从MessageQueue中取出消息，没有消息时会阻塞等待

Message msg = queue.next();

//next()返回了null，表示MessageQueue正在退出，即调用了Looper的quit或quitSafely方法

if (msg == null) {

return;

}

//...

//2、分发消息

msg.target.dispatchMessage(msg);

//...

//3、回收消息

msg.recycleUnchecked();

}

}

loop()中是一个死循环，我们关注注释1，loop()会调用MessageQueue的next()来获取最新的消息，当没有消息时，next()会一直阻塞在那里，这也导致loop()阻塞，唯一跳出循环的条件是next()返回null，这时代表Looper的quit()或quitSafely()被调用，从而调用MessageQueue的quit()来通知消息队列退出，如下：

//Looper.java

public void quit() {

mQueue.quit(false);

}

//quitSafely和quit方法的区别是，quitSafely方法会等MessageQueue中所有的消息处理完后才退出，而quit会直接退出

public void quitSafely() {

mQueue.quit(true);

}

所以MessageQueue的next()是最关键的函数，我们来看看next函数的关键代码：

//MessageQueue.java

Message next() {

//mPtr是在构造中被赋值，是指向native层的MessageQueue

final long ptr = mPtr;

if (ptr == 0) {

return null;

}

int pendingIdleHandlerCount = -1;

int nextPollTimeoutMillis = 0;

//一个死循环，里面分为两部分，1、处理java层消息；2、如果没有消息处理，执行IdleHandler

for(;;){

//...

//Part1：获取java层的消息处理

//nativePollOnce方法用于处理native层消息，是一个阻塞操作

//它在这两种情况下返回：1、等待nextPollTimeoutMillis时长后；2、MessageQueue被唤醒

nativePollOnce(ptr, nextPollTimeoutMillis);

synchronized (this) {

final long now = SystemClock.uptimeMillis();

Message prevMsg = null;

//mMessages是java层的消息队列，这里表示取出消息队列的第一个消息

Message msg = mMessages;

if (msg != null && msg.target == null) {//遇到同步屏障(target为null的消息)

//在do-while中找到异步消息，优先处理异步消息

//异步消息的isAsynchronous方法返回true

do {

prevMsg = msg;

msg = msg.next;

} while (msg != null && !msg.isAsynchronous());

}

if (msg != null) {//有消息

if (now < msg.when) { //消息还没到触发时间

//设置下一次轮询的超时时长(等待时长)

nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);

} else {//now == msg.when, 消息到达触发时间

mBlocked = false;

//从mMessages的头部获取一条消息并返回

if (prevMsg != null) {

prevMsg.next = msg.next;

} else {

mMessages = msg.next;

}

msg.next = null;

//设置消息的使用状态，即flags |= FLAG_IN_US

msg.markInUse();

//返回这个消息

return msg;

}

} else {//msg == null，没有消息

//设置nextPollTimeoutMillis为-1，准备进入阻塞，等待MessageQueue被唤醒

nextPollTimeoutMillis = -1;

}

//调用了quit方法

if (mQuitting) {

dispose();

return null;

}

//当处于以下2种情况时，就会执行到Part2：

//1、mMessages == null，java层没有消息处理

//2、now < msg.when，有消息处理，但是还没有到消息的执行时间

//1、2两种情况都表明线程的消息队列处于空闲状态，处于空闲状态，就会执行IdleHandler

//Part2：没有消息处理，执行IdleHandler

//mIdleHandlers表示IdleHandler列表

//pendingIdleHandlerCount表示需要执行的IdleHandler的数量

if (pendingIdleHandlerCount < 0

&& (mMessages == null || now < mMessages.when)) {

pendingIdleHandlerCount = mIdleHandlers.size();

}

if (pendingIdleHandlerCount <= 0) {

//没有IdleHandler需要处理，可直接进入阻塞

mBlocked = true;

continue;

}

//有IdleHandler需要处理

if (mPendingIdleHandlers == null) {

mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];

}

//把mIdleHandlers列表转成mPendingIdleHandlers数组

mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);

}

//遍历mPendingIdleHandlers数组

for (int i = 0; i < pendingIdleHandlerCount; i++) {

//取出IdleHandler

final IdleHandler idler = mPendingIdleHandlers[i];

mPendingIdleHandlers[i] = null; // release the reference to the handler

boolean keep = false;

try {

//执行IdleHandler的queueIdle方法，通过返回值由自己决定是否保持存活状态

keep = idler.queueIdle();

}

//...省略异常处理

if (!keep) {

// 不需要存活，移除

synchronized (this) {

mIdleHandlers.remove(idler);

}

}

}

//重置pendingIdleHandlerCount和nextPollTimeoutMillis为0

pendingIdleHandlerCount = 0;

//nextPollTimeoutMillis为0，表示下一次循环会马上从Messages中取出一个Message判断是否到达执行时间

//因为IdleHandler在处理事件的时间里，有可能有新的消息发送来过来，需要重新检查

nextPollTimeoutMillis = 0;

}

}

MessageQueue的next方法有点长，但是它里面的逻辑是很好理解的，它主要是通过一个死循环不断的返回Message给Looper处理，next方法可以分为两部分阅读：

1、获取java层的消息处理：

我们看Part1，先执行nativePollOnce方法，它是一个阻塞操作，其中nextPollTimeoutMillis代表下一次等待的超时时长，当nextPollTimeoutMillis = 0时或到达nextPollTimeoutMillis时，它会立即返回；当nextPollTimeoutMillis = -1时，表示MessageQueue中没有消息，会一直等待下去，直到Hanlder往消息队列投递消息，执行nativeWake方法后，MessageQueue被唤醒，nativePollOnce就会返回，但它此时并不是立即返回，它会先处理完native层的消息后，再返回，然后获取java层的消息处理；

接着next方法就会从mMessages链表的表头中获取一个消息，首先判断它是否是同步屏障，同步屏障就是target为null的Message，如果遇到同步屏障，MessageQueue就会优先获取异步消息处理，异步消息就是优先级比同步消息高的消息，我们平时发送的就是同步消息，通过Message的setAsynchronous(true)可以把同步消息变成异步消息，不管是同步还是异步，都是Message，获取到Message后；

接着判断Message是否到达它的执行时间(if(now == msg.when))，如果到达了执行时间，next方法就会返回这条消息给Looper处理，并将其从单链表中删除；如果还没有到达执行时间，就设置nextPollTimeoutMillis为下一次等待超时时长，等待下次再次取出判断，可以发现虽然MessageQueue叫消息队列，但它却不是用队列实现的，而是用链表实现的。

通过MessageQueue的postSyncBarrier方法可以添加一个同步屏障，通过removeSyncBarrier方法可以移除相应的同步屏障，在Android，Choreographer机制中就使用到了异步消息，在View树绘制之前，会先往UI线程的MessageQueue添加一个同步屏障，拦截同步消息，然后发送一个异步消息，等待VSYN信号到来，触发View树绘制，这样就可以让绘制任务优先执行。

2、没有消息处理，遍历IdleHandler列表，执行IdleHandler的queueIdle方法：

IdleHandler是什么？IdleHandler是一个接口，它里面只有一个queueIdle方法，Idle是空闲的意思，在MessageQueue空闲的时候会执行IdleHandler的queueIdle方法，我们可以通过MessageQueue的addIdleHandler方法添加我们自定义的IdleHandler到mIdleHandlers列表中，如下：

//MessageQueue.java

private final ArrayList mIdleHandlers = new ArrayList();

public void addIdleHandler(@NonNull IdleHandler handler) {

//...

mIdleHandlers.add(handler);

}

MessageQueue空闲，就代表它处于以下两种情况：

(1) mMessages == null，消息队列中没有消息处理；

(2) now < msg.when，有消息处理，但是还没有到消息的执行时间.

以上两种情况之一都会触发next方法遍历IdleHandler列表，执行IdleHandler的queueIdle方法的操作。

在Android中，我们平时所说的线程空闲其实就是指线程的MessageQueue空闲，这时就可以执行我们添加的IdleHandler，例如在LeakCanary中，它通过添加IdleHandler，在UI线程空闲时执行内存泄漏的判断逻辑.

4、消息的发送

到这里UI线程已经启动了消息循环，那么消息从何而来？消息是由系统产生，然后通过Hanlder发送到MessageQueue中，Handler就是用来处理和发送消息的，应用程序的Handler在ActivityThread中被创建，如下：

//ActivityThread.java

final H mH = new H();

//H定义如下，继承Hanldler

//里面定义了大量的字段，跟Activity的启动，Application的绑定等有关

class H extends Handler {

public static final int BIND_APPLICATION = 110;

public static final int EXIT_APPLICATION = 111;

public static final int CREATE_SERVICE = 114;

//....

public void handleMessage(Message msg) {

switch (msg.what) {

case BIND_APPLICATION:

//...

case EXIT_APPLICATION:

//...

case CREATE_SERVICE:

//...

//...

}

//...

}

mH就是应用程序内部使用的Handler，我们外部是不可使用的，应用程序通过Handler往MessageQueue中投递消息，并通过Handler的handlerMessage方法处理消息，而我们在外部也可以使用自己创建的Handler往UI线程的MessageQueue投递消息。

既然Handle可以往MessageQueue中投递消息，这说明Handler要和相应的MessageQueue关联，我们看Handler的构造函数，Handler有两种构造函数：

一种是指定Callback的构造函数，Callback默认为null，如下：

//Handler.java

public Handler() {

this(null, false);

}

public Handler(Callback callback) {

this(callback, false);

}

public Handler(boolean async) {

this(null, async);

}

public Handler(Callback callback, boolean async) {

//...

//先通过TLS获取Looper实例，与Looper关联

mLooper = Looper.myLooper();

if (mLooper == null) {

throw new RuntimeException(

"Can't create handler inside thread " + Thread.currentThread()

+ " that has not called Looper.prepare()");

}

//通过Looper获取MessageQueue，与MessageQueue关联

mQueue = mLooper.mQueue;

//Callback的作用在消息的分发中会讲到

mCallback = callback;

mAsynchronous = async;

}

在构造中如果通过Looper.myLooper方法获取不到Looper，就会抛出“Can't create handler inside threadxx that has not called Looper.prepare()”异常，所以如果我们在子线程中使用Handler的默认构造，没有先调用Looper.prepare方法就创建Handler的话，就会抛出上述异常，但是在UI线程中就不会，因为应用程序启动时就已经调用了Looper的prepareMainLooper方法，在该方法里面已经调用了prepare(false)方法创建了UI线程的Looper实例，无需我们再次调用Looper.prepare方法。

另外一种是指定Looper的构造函数(如果不指定，Looper默认从当前线程的TLS区域获取)，如下：

//Handler.java

public Handler(Looper looper) {

this(looper, null, false);

}

public Handler(Looper looper, Callback callback) {

this(looper, callback, false);

}

public Handler(Looper looper, Callback callback, boolean async) {

//与Looper关联

mLooper = looper;

//通过Looper获取MessageQueue，与MessageQueue关联

mQueue = looper.mQueue;

mCallback = callback;

mAsynchronous = async;

}

不管哪一种构造函数，可以看到，在Handler的最终构造中都会和对应线程的Looper、MessageQueue关联，所以就算Hander在子线程创建，我们也可以通过: Handler = new Handler(Looper.getMainLooper)；把Handler关联上UI线程的Looper，并通过Looper关联上UI线程的MessageQueue，这样，就能把Handler运行在UI线程中。

消息的发送可以通过handler的一系列post方法和一系列的send方法，一系列post方法最终通过一系列send方法来实现，一系列send方法最终通过enqueueMessage方法来发送消息，如下：

handler3.png

可以发现Handler所有发送消息的方法，最终都是调用Handler的enqueueMessag方法，该方法源码如下：

//Handler.java

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {

msg.target = this;

if (mAsynchronous) {

msg.setAsynchronous(true);

}

return queue.enqueueMessage(msg, uptimeMillis);

}

在该方法中，首先把Message的target字段设置为当前发送消息的Handler, 然后设置Message是否是异步消息，最后把所有逻辑交给MessageQueue的enqueueMessage方法，该方法的相应源码如下：

//MessageQueue.java

boolean enqueueMessage(Message msg, long when) {

//...

synchronized (this) {

//正在退出时，回收msg，加入到消息池

if (mQuitting) {

//...

msg.recycle();

return false;

}

msg.markInUse();

msg.when = when;

boolean needWake;

//取mMessages链表头部的消息

Message p = mMessages;

//满足以下2种情况之一就把msg插入到链表头部：

//1、如果p为null，则代表mMessages没有消息

//2、如果when == 0 或 when < p.when, 则代表msg的触发时间是链表中最早的

if (p == null || when == 0 || when < p.when) {

msg.next = p;

mMessages = msg;

needWake = mBlocked;//如果处于阻塞状态，需要唤醒

} else {//3、如果p != null且msg并不是最早触发的，就在链表中找一个位置把msg插进去

//如果处于阻塞状态，并且链表头部是一个同步屏障，并且插入消息是最早的异步消息，需要唤醒

needWake = mBlocked && p.target == null && msg.isAsynchronous();

Message prev;

//下面是一个链表的插入操作, 将消息按时间顺序插入到mMessages中

for (;;) {

prev = p;

p = p.next；

if (p == null || when < p.when) {

break;

}

//如果在找到插入位置之前，发现了异步消息的存在，不需要唤醒

if (needWake && p.isAsynchronous()) {

needWake = false;

}

}

msg.next = p;

prev.next = msg;

}

//nativeWake方法会唤醒当前线程的MessageQueue

if (needWake) {

nativeWake(mPtr);

}

}

return true;

}

MessageQueue的enqueueMessage方法主要是一个链表的插入操作，返回true就代表插入成功，返回false就代表插入失败，它主要分为以下3种情况：

1、插入链表头部：

mMessages是按照Message触发时间的先后顺序排列的，越早触发的排得越前，头部的消息是将要最早触发的消息，当有消息需要加入mMessages时，如果mMessages为空或这个消息是最早触发的，就会直接插入链表头部；

2、插入链表的中间位置：

如果消息链表不为空并且插入的消息不是最早触发的，就会从链表头部开始遍历，直到找到消息应该插入的合适位置，以保证所有消息的时间顺序，这一个过程可以理解为插入排序；

3、判断是否调用nativeWake方法

最后，根据needWake是否为true，来决定是否调用nativeWake方法唤醒当前线程的MessageQueue，needWake默认为false，即不需要唤醒，needWake为true就代表此时处于以下2种情况：

(1)如果插入消息在链表头部并且mBlocked == true，表示此时nativePollOnce方法进入阻塞状态，等待被唤醒返回；

(2)如果插入消息在链表中间，消息链表的头部是一个同步屏障，同时插入的消息是链表中最早的异步消息，需要唤醒，即时处理异步消息。

5、消息的分发

在消息循环的运行中，如果loop方法中MessageQueue的next方法返回了Message，那么就会执行到这一句：msg.target.dispatchMessage(msg)；Looper会把这条消息交给该Message的target(Handler对象)来处理, 实际上是转了一圈，Handler把消息发送给MessageQueue，Looper又把这个消息给Handler处理，下面来看消息分发逻辑，dispatchMessage()源码如下：

//Handler.java

public void dispatchMessage(Message msg) {

//1、检查msg的callback是否为空

if (msg.callback != null) {

handleCallback(msg);

} else {

//2、Handler的mCallback是否为空

if (mCallback != null) {

if (mCallback.handleMessage(msg)) {

return;

}

}

//3、我们平常处理消息的方法，该方法默认为空，Handler子类通过覆写该方法来完成具体的逻辑。

handleMessage(msg);

}

}

里面代码量很少，分为3步：

1、检查msg.callback是否为空，不为空则执行" handleCallback(msg)", 源码如下:

//Handler.java

private static void handleCallback(Message message) {

message.callback.run();

}

msg.callback其实是一个Runnable对象，当我们通过Handler来post一个Runnable消息时，它就不为空，如下：

//Handler.java

public final boolean post(Runnable r){

return sendMessageDelayed(getPostMessage(r), 0);

}

//把Runnable对象包装成Message对象

private static Message getPostMessage(Runnable r) {

Message m = Message.obtain();

m.callback = r;

return m;

}

可以看到，在post(Runnable r)中，会把Runnable包装成Message对象，并把Runnable设置给Message的callback字段，然后发送此消息。

2、如果msg.callback为空，检查mCallback是否为空，mCallback是一个Callback接口，定义如下：

//Handler.java

public interface Callback {

public boolean handleMessage(Message msg);

}

当我们这样：Handler handler = new Handler(callback) 来创建Handler时, mCallback就不为空，它的意义是当我们不想派生Handler的子类重写handleMessage()来处理消息时，就可以通过Callback来实现。

3、如果mCallback为空，最后调用Handler的handleMessage方法来处理消息，这就是我们平时熟悉的处理消息的方法。

从1、2、3可以看出，在Handler中，处理消息的回调的优先级为：Message的Callback > Handler的Callback > Handler的handleMessage方法。

6、消息的回收复用

1、消息的复用

前面多次提到了Message，当我们通过Handler的obtainMessage()或Message的obtain()获取一个Message对象时，系统并不是每次都new一个出来，而是先从消息池中(sPool)尝试获取一个Message。Handler的obtainMessage()最终是调用了Message的obtain()，Message的obtain方法如下:

//Message.java

public static Message obtain() {

synchronized (sPoolSync) {

//从sPool头部取出一个Message对象返回，并把消息从链表断开(即把sPool指向下一个Message)

if (sPool != null) {

Message m = sPool;

sPool = m.next;

m.next = null;

m.flags = 0;//清除in-use flag

sPoolSize--;//消息池的大小进行减1操作

return m;

}

}

//消息池中没有Message，直接new一个返回

return new Message();

sPool的数据类型为Message，通过next成员变量，维护一个消息池，消息池的默认大小为50。定义如下:

public final class Message implements Parcelable {

public static final Object sPoolSync = new Object();//用于在获取Message对象时进行同步锁

private static int sPoolSize = 0;//池的大小

private static final int MAX_POOL_SIZE = 50;//池的可用大小

private static Message sPool;

Message next;

//...

}

虽然叫消息池，其实是通过链表实现的，每个Message都有一个同类型的next字段，这个next就是指向下一个可用的Message，最后一个可用的Message的next为空，这样所有可用的Message对象就通过next串成一个Message池，sPool指向池中的第一个Message，复用消息其实是从链表的头部获取一个Message返回。

2、消息的回收

我们发现在obtain方法中新创建Message对象时，并不会直接把它放到池中再返回，那么Message对象是什么时候被放进消息池中的呢？是在回收Message时把它放入池中，Message中也有类似Bitmap那样的recycler函数，如下：

//Message.java

public void recycle() {

//判断消息是否正在使用

if (isInUse()) {

if (gCheckRecycle) {//Android 5.0以后的版本默认为true,之前的版本默认为false.

throw new IllegalStateException("This message cannot be recycled because it "

+ "is still in use.");

}

return;

}

recycleUnchecked();

}

//对于不再使用的消息，加入到消息池

void recycleUnchecked() {

//将消息标示位置为IN_USE，并清空消息所有的参数

flags = FLAG_IN_USE;

what = 0;

arg1 = 0;

arg2 = 0;

obj = null;

replyTo = null;

sendingUid = -1;

when = 0;

target = null;

callback = null;

data = null;

synchronized (sPoolSync) {

//当消息池没有满时，将Message对象加入消息池(即把Message插入链表头部)

if (sPoolSize < MAX_POOL_SIZE) {

next = sPool;

sPool = this;

sPoolSize++;//消息池的可用大小进行加1操作

}

}

}

recycler函数先判断该Message是否还在使用，如果还在使用，就会抛异常，否则就调用recyclerUnchecked函数根据MAX_POOL_SIZE判断是否把该消息回收，回收前还要先清空该消息的各个字段，回收消息就是把自身插入到链表的表头。

通过消息的复用回收，减少Message对象不断创建与销毁的过程，提升了效率。

7、小结

1、创建Looper时，只能通过Looper的prepare方法创建，在创建Looper时会在内部创建一个MessageQueue，并把Looper保存在线程的TLS区域中，一个线程只能对应一个Looper，一个Looper只能对应一个MessageQueue；

2、在创建MessageQueue时，MessageQueue与NativeMessageQueue建立连接，NativeMessageQueue存储地址存于MessageQueue的mPtr字段中，java层和native通过mPtr字段进行通信(native端通过Linux的epoll机制建立起消息机制);

3、由于ThreadLocal的作用，Looper属于某个线程，而MessageQueue存储在Looper中，所以MessageQueue则通过Looper与特定的线程关联上，而Handler在构造中又与Looper和MessageQueue相关联，当我们通过Handler发送消息时，消息就会被插入到Handler关联的MessageQueue中，而Looper会不断的轮询消息，从MessageQueue中取出消息给相应的Handler处理，所以最终通过Handler发送的消息就会被执行到Looper所在线程上，这就是Handler线程切换的原理，无论发送消息的Handler对象处于什么线程，最终处理消息的都是Looper所在线程；

4、Looper从MessageQueue中取出消息后，会交给消息的target(Handler)处理，在Handler中，处理消息的回调的优先级为：Message的Callback > Handler的Callback > Handler的handleMessage方法；

5、因为应用程序启动时在ActivityThread.main方法中的Looper.prepareMainLooper()中已经调用了Looper.prepare(false),所以在主线程中创建Handler无需我们手动调用Looper.prepare()，而在子线程中，如果我们不传递UI线程所属的Looper去创建Handler，那么就需要调用Looper.prepare()后再创建Handle来传递消息，因为Handler要和某个线程中的MessageQueue和Looper关联，只有调用Looper.prepare方法，Looper和MessageQueue才属于某个线程；

6、消息池是一个单链表，复用Message时，从头出取出，如果取不到，则新建返回，回收Message时，也从头插入。

结语

本文从Android应用UI线程消息循环的创建，消息循环的启动，Handler与Looper、MessageQueue的关联，消息的发送与分发，还有消息的复用这几个角度来讲解了Message，Handler，MessageQueue，Looper之间是如何配合工作，在你了解java层的消息机制是如何运作后，希望大家去了解一下native的消息机制，例如要想知道为什么loop方法是死循环但却不会消耗性能，这些只有native层的消息机制才能给你答案.

除此之外，我们还知道了MessageQueue的IdleHandler的作用，它会在线程空闲时工作，还有异步消息的处理，它的优先级高于同步消息，会被优先处理，还有它们的应用场景，一般我们是在子线程切换到UI线程时使用Handler机制，但其实我们也可以在子线程使用Handler机制，可以参考Android中的HandlerThread，它的底层就是Handler+Thread.

以上就是本文的全部内容，希望大家有所收获。

参考资料：