Android 13 Handler详解

1.Handler 简介

Handler 是一套 Android 消息传递机制。在多线程应用场景中，将子线程中需要更新 UI 的操作消息，传递到 UI 主线程，从而实现子线程通知 UI 更新最终实现异步消息处理。说白了是用于线程之间的通信。
Handler主要有4个重要类：Handler、Message、MessageQueue、Looper。

• Handler：负责消息的发送和处理，子线程中使用 sendMessage() 发送消息；在handleMessage()中处理。
• Message：消息载体，里面存储这线程消息。
• MessageQueue：消息队列，遵循先进先出的原则，存储着 sendMessage() 发送来的子线程消息。
• Looper：消息循环器，负责从 MessageQueue 中循环取消息，再将取出的消息分发给handleMessage()，来处理消息。

2.Handler原理

3.Handler 源码

了解 Handler，首先我们要了解 Handler 从消息发送到消息处理这整个流程，下面将分析这一流程，并回答下面几个问题：

1. 一个线程有几个Handler?
2. 一个线程有几个Looper？如何保证？
3. Handler 内存泄漏原因？为什么其他的内部分没有过这个问题？
4. 为何主线程可以 new Handler？如果想要在子线程中 new Handler 要做些什么准备？
5. 子线程中的维护的 looper，消息队列无消息的时候处理方案是什么？有什么用？
6. 既然可以存在多个 Handler 往 MessageQueue 中添加数据（发消息时，各个handler 可能处于不同的线程），那么它内部是如何确保线程安全的？
7. 我们使用 Message 时应如何创建它？
8. 使用 Handler 的 postDelay 后，消息队列会有什么变化？
9. Looper 死循环为什么不会导致应用卡死(ANR)?

Handler

Handler 负责消息的发送和处理，该类中通过 sendXXX、postXXX等方法发送消息，共有14个这样的方法。而在 handleMessage() 中处理收到的消息。
这里以 sendMessage(Message msg) 方法为例进行源码分析。
frameworks/base/core/java/android/os/Handler.java

public class Handler {
   
    ......
    public final boolean sendMessage(@NonNull Message msg) {
   
        return sendMessageDelayed(msg, 0);
    }

    public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
   
        if (delayMillis < 0) {
   
            delayMillis = 0;
        }
        // 第二的参数代表执行的时间，为：系统当前时间+延迟的时间
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

    public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
   
        MessageQueue queue = mQueue;
        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);
    }

    // 不管使用什么方法发送消息，都会调到 Handler#enqueueMessage()
    private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
            long uptimeMillis) {
   
        // 把当前对象赋给msg.target，这样 Message 就持有了 Handler
        msg.target = this;
        msg.workSourceUid = ThreadLocalWorkSource.getUid();
        if (mAsynchronous) {
   
            msg.setAsynchronous(true);
        }
        // 调用 MessageQueue#enqueueMessage() 往消息队列添加消息。
        return queue.enqueueMessage(msg, uptimeMillis);
    }
    ......
}

MessageQueue

enqueueMessage 里面其实是一个优先级队列，将收到消息根据执行的时间 when 进行做排序处理。
frameworks/base/core/java/android/os/MessageQueue.java

public final class MessageQueue {
   
    ......
    boolean enqueueMessage(Message msg, long when) {
   
        if (msg.target == null) {
   
            throw new IllegalArgumentException("Message must have a target.");
        }
        synchronized (this) {
   
            if (msg.isInUse()) {
   
                throw new IllegalStateException(msg + " This message is already in use.");
            }
            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;
            }
            msg.markInUse();
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            // 如果是0，则放在最前面
            if (p == null || when == 0 || when < p.when) {
   
                // New head, wake up the event queue if blocked.
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
   
                // Inserted within the middle of the queue.  Usually we don't have to wake
                // up the event queue unless there is a barrier at the head of the queue
                // and the message is the earliest asynchronous message in the queue.
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;
                // 对单链表轮询，根据 when 进行排序插入消息。
                for (;;) {
   
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when