“
文章相关内容已授权『郭霖』公众号发布
”

前言

很高兴遇见你~ 欢迎阅读我的文章。

本文是系列文章的第三部分，主要内容是介绍Handler的内部关键类：Message、MessageQueue、Looper。从本文开始就来介绍Handler的底层原理了。

“
Handler系列文章共分为6个部分：

第一部分：系列开篇，从0开始认识Handler；
第二部分：介绍Handler内部模式，详解关键类ThreadLocal；
第三部分：解析Handler内部关键类：Message、MessageQueue、Looper；
第四部分：解析Handler内部关键类：Handler,同时介绍HandlerThread；
第五部分：总结Handler，从源码设计角度思考Handler；
第六部分：Handler常见问题解答；

本文为系列文章的第三部分。读者可前往笔者主页选择感兴趣的部分阅读。
”

那么，我们开始吧。

正文

Message

概述

Message是负责承载消息的类，主要是关注他的内部属性：

// 用户自定义，主要用于辨别Message的类型
public int what;
// 用于存储一些整型数据
public int arg1;
public int arg2;
// 可放入一个可序列化对象
public Object obj;
// Bundle数据
Bundle data;
// Message处理的时间。相对于1970.1.1而言的时间
// 对用户不可见
public long when;
// 处理这个Message的Handler
// 对用户不可见
Handler target;
// 当我们使用Handler的post方法时候就是把runnable对象封装成Message
// 对用户不可见
Runnable callback;
// MessageQueue是一个链表，next表示下一个
// 对用户不可见
Message next;

循环利用Message

当我们获取Message的时候，官方建议是通过Message.obtain()方法来获取，当使用完之后使用recycle()方法来回收循环利用。而不是直接new一个新的对象：

public static Message obtain() {
    synchronized (sPoolSync) {
        if (sPool != null) {
            Message m = sPool;
            sPool = m.next;
            m.next = null;
            m.flags = 0; 
            sPoolSize--;
            return m;
        }
    }
    return new Message();
}

Message维护了一个静态链表，链表头是sPool,Message有一个next属性，Message本身就是链表结构。sPoolSync是一个object对象，仅作为解决并发访问安全设计。当我们调用obtain来获取一个新的Message的时候，首先会检查链表中是否有空闲的Message，如果没有则新建一个返回。

当我们使用完成之后，可以调用Message的recycle方法进行回收，如果这个Message正在使用则会抛出异常，否则则调用recycleUnchecked进行回收，把Message中的内容清空，然后判断链表是否达到最大值（50），然后插入链表中。相关源码读者可自行查看，限于篇幅这里就不展示了。

Message总结

Message的作用就是承载消息，他的内部有很多的属性用于给用户赋值。同时Message本身也是一个链表结构，无论是在MessageQueue还是在Message内部的回收机制，都是使用这个结构来形成链表。同时官方建议不要直接初始化Message，而是通过Message.obtain()方法来获取一个Message循环利用。一般来说我们不需要去调用recycle进行回收，在Looper中会自动把Message进行回收，后面会讲到。

MessageQueue

概述

每个线程都有且只有一个MessageQueue，他是一个用于承载消息的队列，内部使用链表作为数据结构，所以待处理的消息都会在这里排队。前面讲到ThreadLocalMap是一个“修改版的HashMap”，而MessageQueue就是一个“修改版的LinkQueue”。他也有两个关键的方法：入队（enqueueMessage）和出队（next）。这也是MessageQueue的重点所在。

Message还涉及到一个关键概念：线程休眠。当MessageQueue中没有消息或者都在等待中，则会将线程休眠，让出cpu资源，提高cpu的利用效率。进入休眠后，如果需要继续执行代码则需要将线程唤醒。当方法暂时无法直接返回需要等待的时候，则可以将线程阻塞，即休眠，等待被唤醒继续执行逻辑。这部分内容也会在后面详细讲。

关键方法

出队 -- next()

next方法主要是做消息出队工作。

Message next() {
    // 如果looper已经退出了，这里就返回null
    final long ptr = mPtr;
    if (ptr == 0) {
        return null;
    }
    ...
    // 阻塞时间
    int nextPollTimeoutMillis = 0;
    for (;;) {
        if (nextPollTimeoutMillis != 0) {
            Binder.flushPendingCommands();
        }
        // 阻塞对应时间 
        nativePollOnce(ptr, nextPollTimeoutMillis);
    // 对MessageQueue进行加锁，保证线程安全
        synchronized (this) {
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;
            ...
            if (msg != null) {
                if (now < msg.when) {
                    // 下一个消息还没开始，等待两者的时间差
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                } else {
                    // 获得消息且现在要执行，标记MessageQueue为非阻塞
                    mBlocked = false;
                    // 链表操作
                    if (prevMsg != null) {
                        prevMsg.next = msg.next;
                    } else {
                        mMessages = msg.next;
                    }
                    msg.next = null;
                    msg.markInUse();
                    return msg;
                }
            } else {
                // 没有消息，进入阻塞状态
                nextPollTimeoutMillis = -1;
            }
           ...
    }
}

代码很长，其中还涉及了同步屏障和IdleHandler，这两部分内容我放在后面讲，这里先讲主要的出队逻辑。代码中我都加了注释，这里还是再讲一下。next方法目的是获取MessageQueue中的一个Message，如果队列中没有消息的话，就会把方法阻塞住，等待新的消息来唤醒。主要步骤如下：

如果Looper已经退出了，直接返回null
进入死循环，直到获取到Message或者退出
循环中先判断是否需要进行阻塞，阻塞结束后，对MessageQueue进行加锁，获取Message
如果MessageQueue中没有消息，则直接把线程无限阻塞等待唤醒；
如果MessageQueue中有消息，则判断是否需要等待，否则则直接返回对应的message。

可以看到逻辑就是判断当前时间Message中是否需要等待。其中nextPollTimeoutMillis表示阻塞的时间，-1表示无限时间，只有通过唤醒才能打破阻塞。

入队 -- enqueueMessage()

MessageQueue.class

boolean enqueueMessage(Message msg, long when) {
    // Hanlder不允许为空
    if (msg.target == null) {
        throw new IllegalArgumentException("Message must have a target.");
    }
    if (msg.isInUse()) {
        throw new IllegalStateException(msg + " This message is already in use.");
    }

    // 对MessageQueue进行加锁
    synchronized (this) {
        // 判断目标thread是否已经死亡
        if (mQuitting) {
            IllegalStateException e = new IllegalStateException(
                    msg.target + " sending message to a Handler on a dead thread");
            Log.w(TAG, e.getMessage(), e);
            msg.recycle();
            return false;
        }
        // 标记Message正在被执行，以及需要被执行的时间，这里的when是距离1970.1.1的时间
        msg.markInUse();
        msg.when = when;
        // p是MessageQueue的链表头
        Message p = mMessages;
        boolean needWake;
        // 判断是否需要唤醒MessageQueue
        // 如果有新的队头，同时MessageQueue处于阻塞状态则需要唤醒队列
        if (p == null || when == 0 || when < p.when) {
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
        } else {
            ...
            // 根据时间找到插入的位置
            Message prev;
            for (;;) {
                prev = p;
                p = p.next;
                if (p == null || when < p.when) {
                    break;
                }
                ...
            }
            msg.next = p; 
            prev.next = msg;
        }

        // 如果需要则唤醒队列
        if (needWake) {
            nativeWake(mPtr);
        }
    }
    return true;
}

这部分的代码好像也很多，但是逻辑也是不复杂，主要就是链表操作以及判断是否需要唤醒MessageQueue，代码中我加了一些注释，下面再总结一下：

首先判断message的目标handler不能为空且不能正在使用中
对MessageQueue进行加锁
判断目标线程是否已经死亡，死亡则直接返回false
初始化Message的执行时间以及标记正在执行中
然后根据Message的执行时间，找到在链表中的插入位置进行插入
同时判断是否需要唤醒MessageQueue。有两种情况需要唤醒：当新插入的Message在链表头时，如果messageQueue是空的或者正在等待下个任务的延迟时间执行，这个时候就需要唤醒MessageQueue。

MessageQueue总结

Message两大重点：阻塞休眠和队列操作。基本都是围绕着两点来展开。而源码中还涉及到了同步屏障以及IdleHandler，这两部分内容我分开到了最后一部分的相关问题中讲。平时用的比较少，但也是比较重要的内容。

Looper

概述

Looper可以说是Handler机制中的一个非常重要的核心。Looper相当于线程消息机制的引擎，驱动整个消息机制运行。Looper负责从队列中取出消息，然后交给对应的Handler去处理。如果队列中没有消息，则MessageQueue的next方法会阻塞线程，等待新的消息的到来。每个线程有且只能有一个“引擎”，也就是Looper，如果没有Looper，那么消息机制就运行不起来，而如果有多个Looper，则会违背单线操作的概念，造成并发操作。

每个线程仅有一个Looper，由不同Looper分发的Message运行在不同的线程中。Looper的内部维护一个MessageQueue，当初始化Looper的时候会顺带初始化MessageQueue。

Looper使用ThreadLocal来保证每个线程都有且只有一个相同的副本。

关键方法

prepare ：初始化Looper

Looper.class

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

public static void prepare() {
    prepare(true);
}

// 最终调用到了这个方法
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));
}

每个线程使用Handler之前，都必须调用Looper.prepare()方法来初始化当前线程的Looper。参数quitAllowed表示该Looper是否可以退出。主线程的Looper是不能退出的，不然程序就直接终止了。我们在主线程使用Handler的时候是不用初始化Looper的，为什么？因为Activiy在启动的时候就已经帮我们初始化主线程Looper了，这点在后面再详细展开。所以在主线程我们可以直接调用Looper.myLooper()获取当前线程的Looper。

prepare方法重点在sThreadLocal.set(new Looper(quitAllowed));，可以看出来这里使用了ThreadLocal来创建当前线程的Looper对象副本。如果当前线程已经有Looper了，则会抛出异常。sThreadLocal是Looper类的静态变量，前面我们介绍过了ThreadLocal了，这里每个线程调用一次prepare方法就可以初始化当前线程的Looper了。

接下来再看到Looper的构造方法：

private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}

逻辑很简单，初始化了一个MessageQueue，再把当前的线程的Thread对象赋值给mThread。

myLooper() ：获取当前线程的Looper对象

获取当前线程的Looper对象。这个方法就是直接调用ThreadLocal的get方法：

public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
}

loop() : 循环获取消息

当Looper初始化完成之后，他是不会自己启动的，需要我们自己去启动Looper，调用Looper的loop()方法即可:

public static void loop() {
    // 获取当前线程的Looper
    final Looper me = myLooper();
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    final MessageQueue queue = me.mQueue;
    ...
    for (;;) {
        // 获取消息队列中的消息
        Message msg = queue.next(); // might block
        if (msg == null) {
            // 返回null说明MessageQueue退出了
            return;
        }
        ...
        try {
            // 调用Message对应的Handler处理消息
            msg.target.dispatchMessage(msg);
            if (observer != null) {
                observer.messageDispatched(token, msg);
            }
            dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
        }
        ...
    // 回收Message
        msg.recycleUnchecked();
    }
}

loop()方法就是Looper这个“引擎”的核心所在。首先获取当前线程的Looper对象，没有则抛出异常。然后进入一个死循环：不断调用MessageQueue的next方法来获取消息，然后调用message的目标handler的dispatchMessage方法来处理Message。

前面我们了解过了MessageQueue，next方法是可能会进行阻塞的：当MessageQueue为空或者目前没有任何消息需要处理。所以Looper就会一直等待，阻塞在里，线程也就不会结束。当我们退出Looper的时候，next方法会返回null，那么Looper也就会跟着结束了。

同时，因为Looper是运行在不同线程的逻辑，其调用的dispatchMessage方法也是运行在不同的线程，这就达到了切换线程的目的。

quit/quitSafely : 退出Looper

quit是直接将Looper退出，quitSafely是将MessageQueue中的不需要等待的消息处理完成之后再退出，看一下代码：

public void quit() {
    mQueue.quit(false);
}
// 最终都是调用到了这个方法
void quit(boolean safe) {
    // 如果不能退出则抛出异常。这个值在初始化Looper的时候被赋值
    if (!mQuitAllowed) {
        throw new IllegalStateException("Main thread not allowed to quit.");
    }

    synchronized (this) {
        // 退出一次之后就无法再次运行了
        if (mQuitting) {
            return;
        }
        mQuitting = true;
    // 执行不同的方法
        if (safe) {
            removeAllFutureMessagesLocked();
        } else {
            removeAllMessagesLocked();
        }
        // 唤醒MessageQueue
        nativeWake(mPtr);
    }
}

我们可以发现最后都调用了quitSafely方法。这个方法先判断是否能退出，然后再执行退出逻辑。如果mQuitting==true，那么这里会直接方法，我们会发现mQuitting这个变量只有在这里被执行了赋值，所以一旦looper退出，则无法再次运行了。之后执行不同的退出逻辑，removeAllMessagesLocked()是直接把所有的Message移除，而后者先把执行时间为当前时间或更早的Message先执行后再移除剩下需要延迟执行的Message。相关的源码限于篇幅这里就不展示了，读者可自行查看源码。之后MessageQueue的next方法会退出，Looper的loop方法也会跟着退出，那么线程也就停止了。

Looper总结

Looper作为Handler消息机制的“动力引擎”，不断从MessageQueue中获取消息，然后交给Handler去处理。Looper的使用前需要先初始化当前线程的Looper对象，再调用loop方法来启动它。

同时Handler也是实现切换的核心，因为不同的Looper运行在不同的线程，他所调用的dispatchMessage方法则运行在不同的线程，所以Message的处理就被切换到Looper所在的线程了。当looper不再使用时，可调用不同的退出方法来退出他，注意Looper一旦退出，线程则会直接结束。

最后

文章介绍了三个非常重要的类，他们事Handler机制的组成部分。剩下的Handler关键类将在下一节讲解。

希望文章对你有帮助。

“
全文到此，原创不易，觉得有帮助可以点赞收藏评论转发。笔者才疏学浅，有任何想法欢迎评论区交流指正。如需转载请私信交流。

另外欢迎光临笔者的个人博客：传送门
”

Android全面解析之Handler机制（三）：内部关键类

前言

正文

Message

概述

循环利用Message

Message总结

MessageQueue

概述

关键方法

MessageQueue总结

Looper

概述

关键方法

Looper总结

最后