Handler都没搞懂，拿什么去跳槽啊？

内容分享11个月前发布

12 1 0

01. 前言

做 Android 开发肯定离不开跟 Handler 打交道，它一般被我们用来做主线程与子线程之间的通信工具，而 Handler 作为 Android 中消息机制的重大一员也的确给我们的开发带来了极大的便利。

Handler应用之广泛，可以说只要有异步线程与主线程通信的地方就必定会有 Handler。

所以搞懂 Handler 对理解Android超级有必要。

那么，Handler 的通信机制的背后的原理是什么？

本文带你揭晓。

注意：本文所展示的系统源码基于 Android-27 ，并有所删减.

1. 重识 Handler

我们可以使用 Handler发送并处理与一个线程关联的 Message 和 Runnable 。（注意：Runnable 会被封装进一个 Message，所以它本质上还是一个 Message）

每个 Handler 都会跟一个线程绑定，并与该线程的 MessageQueue 关联在一起，从而实现消息的管理以及线程间通信。

1.1 Handler 的基本用法

1android.os.Handler handler = new Handler(){
2  @Override
3  public void handleMessage(final Message msg) {
4    //这里接受并处理消息
5  }
6};
7//发送消息
8handler.sendMessage(message);
9handler.post(runnable);

实例化一个 Handler 重写 handleMessage 方法，然后在需要的时候调用它的 send 以及 post 系列方法就可以了，超级简单易用，并且支持延时消息。（更多方法可查询 API 文档）

但是奇怪，我们并没有看到任何 MessageQueue 的身影，也没看到它与线程绑定的逻辑，这是怎么回事？

2. Handler 原理解析

信任大家早就听说过了 Looper 以及 MessageQueue 了，我就不多绕弯子了。

不过在开始分析原理之前，先明确我们的问题：

1. Handler 是如何与线程关联的？

2. Handler 发出去的消息是谁管理的？

3. 消息又是怎么回到 handleMessage() 方法的？

4. 线程的切换是怎么回事？

2.1 Handler 与 Looper 的关联

实际上我们在实例化 Handler 的时候 Handler 会去检查当前线程的 Looper 是否存在，如果不存在则会报异常，也就是说在创建 Handler 之前必定需要先创建 Looper 。

代码如下：

1public Handler(Callback callback, boolean async) {
 2        //检查当前的线程是否有 Looper
 3        mLooper = Looper.myLooper();
 4        if (mLooper == null) {
 5            throw new RuntimeException(
 6                "Can't create handler inside thread that has not called Looper.prepare()");
 7        }
 8        //Looper 持有一个 MessageQueue
 9        mQueue = mLooper.mQueue;
10}

这个异常信任许多同学遇到过，而我们平时直接使用感受不到这个异常是由于主线程已经为我们创建好了 Looper，先记住，后面会讲。（见【3.2】）

一个完整的 Handler 使用例子实则是这样的：

1class LooperThread extends Thread {
 2    public Handler mHandler;
 3    public void run() {
 4        Looper.prepare();
 5        mHandler = new Handler() {
 6            public void handleMessage(Message msg) {
 7                // process incoming messages here
 8            }
 9        };
10        Looper.loop();
11    }
12}

Looper.prepare() :

1//Looper
2private static void prepare(boolean quitAllowed) {
3  if (sThreadLocal.get() != null) {
4    throw new RuntimeException("Only one Looper may be created per thread");
5  }
6  sThreadLocal.set(new Looper(quitAllowed));
7}

Looper 提供了 Looper.prepare() 方法来创建 Looper ，并且会借助 ThreadLocal 来实现与当前线程的绑定功能。Looper.loop() 则会开始不断尝试从 MessageQueue 中获取 Message , 并分发给对应的 Handler（见【2.3】）。

也就是说 Handler 跟线程的关联是靠 Looper 来实现的.

2.2 Message 的存储与管理

Handler 提供了一些列的方法让我们来发送消息，如 send()系列 post()系列。

不过不管我们调用什么方法，最终都会走到 `Message.enqueueMessage(Message,long)` 方法。

以 sendEmptyMessage(int) 方法为例：

1//Handler
2sendEmptyMessage(int)
3  -> sendEmptyMessageDelayed(int,int)
4    -> sendMessageAtTime(Message,long)
5      -> enqueueMessage(MessageQueue,Message,long)
6              -> queue.enqueueMessage(Message, long);

到了这里，消息的管理者 MessageQueue 也就露出了水面。

MessageQueue 顾明思议，就是个队列，负责消息的入队出队。

2.3 Message 的分发与处理

了解清楚 Message 的发送与存储管理后，就该揭开分发与处理的面纱了。

前面说到了 Looper.loop() 负责对消息的分发，本章节进行分析。

先来看看所涉及到的方法：

1//Looper
 2public static void loop() {
 3    final Looper me = myLooper();
 4    if (me == null) {
 5        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
 6    }
 7    final MessageQueue queue = me.mQueue;
 8    //...
 9    for (;;) {
10       // 不断从 MessageQueue 获取 消息
11        Message msg = queue.next(); // might block
12        //退出 Looper 
13        if (msg == null) {
14            // No message indicates that the message queue is quitting.
15            return;
16        }
17        //...
18        try {
19            msg.target.dispatchMessage(msg);
20            end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
21        } finally {
22            //...
23        }
24        //...
25                //回收 message, 见【3.5】
26        msg.recycleUnchecked();
27    }
28}

loop() 里调用了 MessageQueue.next() :

1//MessageQueue
 2Message next() {
 3    //...
 4    for (;;) {
 5        //...
 6        nativePollOnce(ptr, nextPollTimeoutMillis);
 7
 8        synchronized (this) {
 9            // Try to retrieve the next message.  Return if found.
10            final long now = SystemClock.uptimeMillis();
11            Message prevMsg = null;
12            Message msg = mMessages;
13            //...
14            if (msg != null) {
15                if (now < msg.when) {
16                    // Next message is not ready.  Set a timeout to wake up when it is ready.
17                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
18                } else {
19                    // Got a message.
20                    mBlocked = false;
21                    if (prevMsg != null) {
22                        prevMsg.next = msg.next;
23                    } else {
24                        mMessages = msg.next;
25                    }
26                    msg.next = null;
27                    return msg;
28                }
29            } else {
30                // No more messages.
31                nextPollTimeoutMillis = -1;
32            }
33
34            // Process the quit message now that all pending messages have been handled.
35            if (mQuitting) {
36                dispose();
37                return null;
38            }
39        }
40
41        // Run the idle handlers. 关于 IdleHandler 自行了解
42        //...
43    }
44}

还调用了 `
msg.target.dispatchMessage(msg)` ，msg.target 就是发送该消息的 Handler，这样就回调到了 Handler 那边去了:

1//Handler
 2public void dispatchMessage(Message msg) {
 3  //msg.callback 是 Runnable ，如果是 post方法则会走这个 if
 4  if (msg.callback != null) {
 5    handleCallback(msg);
 6  } else {
 7    //callback 见【3.4】
 8    if (mCallback != null) {
 9      if (mCallback.handleMessage(msg)) {
10        return;
11      }
12    }
13    //回调到 Handler 的 handleMessage 方法
14    handleMessage(msg);
15  }
16}

注意：dispatchMessage() 方法针对 Runnable 的方法做了特殊处理，如果是，则会直接执行 Runnable.run() 。

分析：Looper.loop() 是个死循环，会不断调用 MessageQueue.next() 获取 Message ，并调用
msg.target.dispatchMessage(msg) 回到了 Handler 来分发消息，以此来完成消息的回调。

那么线程的切换又是怎么回事呢？

许多人搞不懂这个原理，但是实则超级简单，我们将所涉及的方法调用栈画出来，如下：

1Thread.foo(){
2    Looper.loop()
3     -> MessageQueue.next()
4       -> Message.target.dispatchMessage()
5        -> Handler.handleMessage()
6}

显而易见，Handler.handleMessage() 所在的线程最终由调用 Looper.loop() 的线程所决定。

平时我们用的时候从异步线程发送消息到 Handler，这个 Handler 的 handleMessage() 方法是在主线程调用的，所以消息就从异步线程切换到了主线程。