Handler机制源码详解

2020-10-02 本文已影响0人 CoderCyl

Handler对于Android系统来说可以是非常重要的了，因为它贯穿了整个Android系统，它随处可见，没有Handler，Android系统也就不起作用了。

流程介绍

Android系统是以消息驱动的，整个流程可以大致概括为：

发送消息 --> 添加消息到队列 --> 从队列中获取消息 --> 处理消息

上面的流程可以引出几个类分别是，发送消息的Handler，将消息Message发送到消息队列MessageQueue，Looper从消息队列循环取出消息，然后交给Handler处理。

在这里插入图片描述

Handler：消息发送和处理
Message：被发送和处理的消息
MessageQueue：存放消息的消息队列
Looper：循环的从MessageQueue中取消息给Handler处理

源码解析

发送消息

发送消息有send和post的方式：

// 发送消息
Handler handelr = new Handler();
// 发送方式一
handler.sendMessage(msg); // 或者handler.sendEmptyMessage(what);

// 发送方式二
handler.postXXX(runnable);

handler.sendXXX()和handler.postXXX()最终都会调用到sendMessageDelayed()方法。

public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
    if (delayMillis < 0) {
        delayMillis = 0;
    }
    // 注意sendMessageAtTime方法的第二个参数，当前时间加上延时时间
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

然后调用了sendMessageAtTime方法

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); // uptimeMillis = SystemClock.uptimeMillis() + delayMillis
}

又调用了enqueueMessage()方法

private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg, long uptimeMillis) {
    msg.target = this;
    msg.workSourceUid = ThreadLocalWorkSource.getUid();

    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis); // uptimeMillis = SystemClock.uptimeMillis() + delayMillis
}

然后又调用了MessageQueue的enqueueMessage()方法

boolean enqueueMessage(Message msg, long when) { // when = SystemClock.uptimeMillis() + delayMillis
    ... // 省略无关代码
    synchronized (this) {
        ...
            
        msg.markInUse();
        msg.when = when;
        Message p = mMessages;
        boolean needWake;
        if (p == null || when == 0 || when < p.when) {
            // New head, wake up the event queue if blocked.
            // 当消息队列为空或者将要入队的消息(msg)的时间(when)在所有消息队列的消息最前面，则把msg插入到队头,最先执行
            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;
            for (;;) {
                prev = p;
                p = p.next;
                if (p == null || when < p.when) {
                    // 当p为空(遍历到最后一个了)，或者新消息的时间在p的时间之前，就不用再遍历了，因为可以确定新消息要插在消息p前面了
                    break;
                }
                if (needWake && p.isAsynchronous()) {
                    needWake = false;
                }
            }
            
            // break跳出for循环后执行到这里，将msg插入到p前面，prev后面
            msg.next = p; // invariant: p == prev.next
            prev.next = msg;
        }
        ...
    }
    return true;
}

看Message类的实现可以看出它是个单链表，消息队列中的消息都是按照时间先后顺序链接起来的。

接下来详细分析一下上述代码，在if分支中有三个条件判断p == null || when == 0 || when < p.when，

p == null：当p也就是mMessages为空，表示消息队列中还没添加过消息
when == 0：when表示当前时间SystemClock.uptimeMillis()加上延迟时间delayMillis，所以when == 0这个条件应该是一直返回false
when < p.when：新消息的时间when小于p消息的时间p.when

以上三个条件只要满足任一条件都会执行到if代码块中的语句，将新消息添加到p消息的前面，p消息为空时，即队头。

当添加新消息时，消息队列中是有消息的，就会执行到else语句中。先来看看下面代码是什么意思：

prev = p;
p = p.next;

第一行代码中的p就是在if代码块中添加的消息，说明指针指向p消息，第二行代码又将指针指向了p消息的下一个消息。没错，指针向后移动了一位。为什么要这样呢？

从上面2行代码中可以看出，再次添加消息时，遍历消息都是从添加if代码块中的消息开始的，因为从if代码块中添加的消息要么就是第一个消息，要么就是when小于p消息的wnen的，也就是说可确保前面的消息都是时间有序递增的。而系统的时间是一直在增加的，所以enqueueMessage()方法的第二个参数when一直大于mMessages的when，所以要把指针向后移一位，从后面一个消息开始比对。

上图加深理解（图中所有msg的when为了偏于比较和理解，都是用的比较小的数字，而没有使用时间戳）：

在这里插入图片描述

添加第一个消息时，消息队列中是没有消息的，直接将消息msg1添加到消息队列的头部。

在这里插入图片描述

当添加第二个消息时，消息队列中已经有消息msg1，此时不满足if的条件，执行到else中的代码，因为p = mMessages，而mMessages在添加第一个消息时被赋值成了msg1，代码p = p.next将指针指向了msg1的下一个，也就是null，即p = null。当p == null时会跳出循环，会执行到

msg.next = p
prev.next = msg

也就是将msg2的下一个节点设置成p，即将msg2消息插入到p的前面。如下图：

在这里插入图片描述

上面添加的两个消息不是插入到队头就是队尾，再插入一个到中间的消息看看代码是怎么执行的。

在这里插入图片描述

因为mMessage只在添加msg1的时候被赋值了，所以p = mMessage = msg1，接下来执行if的判断条件if (p == null || when == 0 || when < p.when)，p = msg，when = 4，p.when = 1，不满足if条件，执行到else中的代码。

再来看else中的for循环，p = p.next将指针移到了msg2的位置，此时p = msg2，when = 4，p.when = 5，满足了for循环的if条件when < p.when

for (;;) {
    prev = p;
    p = p.next;
    if (p == null || when < p.when) { // 满足了该条件，跳出循环
        break;
    }
    if (needWake && p.isAsynchronous()) {
        needWake = false;
    }
}

跳出循环后，执行代码

msg.next = p; // invariant: p == prev.next
prev.next = msg;

将msg3插入到msg2前面，至此msg3的插入流程就走完了。

突然发现，好像除了添加msg1的时候执行到了if中的代码，后面都是执行else的代码。那在什么情况下会再次执行if中的代码呢？从if的条件中可以看出，此时p = msg1不会为空，when实际上是当前时间的时间戳，也不会等于0，所以只有当when < p.when的时候才会再次执行到if中的代码。

那再次发送一个消息msg4，假设msg.when = 0（实际上不会为0，这里为了方便假设为0，这个0不等于if条件中的0），满足条件后执行

msg.next = p;
mMessages = msg;

将msg4插入到p的前面，也就是msg1的前面了，然后又刷新了mMessages的值了。

在这里插入图片描述

总结

添加第一个消息时，将消息添加到消息队列的队头
再次添加消息时，先判断待添加消息的when和p.when的大小关系，小于p.when，则把消息添加到p的前面，否则循环消息队列找出合适的插入位置
如果遍历完整个消息队列都没有满足条件的位置，则把新消息插入到队尾
消息队列的消息按照时间从先到后排序

取出消息

开头说过整个系统是以消息驱动的，那么Looper就是其动力了，Looper.loop()方法不断的从MessageQueue中取消息。那么Looper.loop()方法是在哪里调用的呢？由于系统都是由消息驱动的，所以在系统启动的时候就应该有动力驱动了，在SystemServer.main()中调用了Looper.loop()，这是在系统层面的驱动，而对于APP应用层面来说，应用入口ActivityThread.main()中也需要调用Looper.loop()，毕竟APP也是需要各种事件响应的嘛。来看看loop()的代码：

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; // 获取消息队列，获取到了消息队列后才能从消息队列中取出消息

    ... // 省略无关代码

    for (;;) {
        Message msg = queue.next(); // 获取消息，无消息时可能会阻塞
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }

        ... // 省略无关代码
            
        // Make sure the observer won't change while processing a transaction.
        final Observer observer = sObserver;

        ... // 省略无关代码

        Object token = null;
        if (observer != null) {
            token = observer.messageDispatchStarting(); // 开始分发消息
        }

        try {
            msg.target.dispatchMessage(msg); // 分发处理消息
            if (observer != null) {
                observer.messageDispatched(token, msg); // 消息分发处理完成
            }
            dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
        } catch (Exception exception) {
            if (observer != null) {
                observer.dispatchingThrewException(token, msg, exception); // 消息分发异常
            }
            throw exception;
        } finally {
        }
        ... // 省略无关代码
        msg.recycleUnchecked(); // 回收消息
    }
}

首先要获取到Looper对象，当Looper对象为空时抛出异常No Looper; Looper.prepare() wasn't called on this thread.，我们就知道调用loop()方法之前需要先调用prepare()方法，在prepare()中创建出了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));
}

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

在创建Looper时创建了MessageQueue，sThreadLocal保证了一个线程只有一个Looper，而一个Looper又只有一个MessageQueue。

插入话题来看看ThreadLocal是怎么做到这些的。

回头看看prepare()方法，首先调用sThreadLocal.get()获取Looper，如果不为空说明已经创建过Looper了，为空就创建一个Looper保存在sThreadLocal中，看看sThreadLocal.get()的实现：

// 获取泛型T，这里是Looper
public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

// 获取当前线程的ThreadLocalMap
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

// 当ThreadLocalMap为空时，设置初始值
private T setInitialValue() {
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

protected T initialValue() {
    return null;
}

// 创建ThreadLocalMap
void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

获取到当前线程，然后根据当前线程获取ThreadLocalMap，ThreadLocalMap是Thread的一个变量，表明一个线程只有一个ThreadLocalMap。接着判断ThreadLocalMap是否是空，为空则创建一个，否则就获取ThreadLocalMap中的值。再来看看sThreadLocal.set(T)方法：

# ThreadLocal.java
public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value); // this就是sThreadLocal，static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    else
        createMap(t, value);
}

set()方法中先是获取了当前线程，然后根据当前线程获取ThreadLocalMap，当map为空时就根据当前线程创建一个，否则就将value设置到map中。从map.set(this, value)可以看出，是用当前ThreadLocal对象sThreadLocal作为key，sThreadLocal是所有线程共享的，一个线程只有一个ThreadLocalMap，而一个ThreadLocalMap在key = this时只能获取到一个value。

再回头看看Looper.prepare()方法中的sThreadLocal.get()方法，从sThreadLocal.set()方法中我们已经知道了Looper和线程是一一对应的关系，从当前线程中获取的Looper不为空时就抛出异常，这样就避免了Looper再次创建。

在这里插入图片描述

话题转回来，获取到了looper对象后，就从looper中获取MessageQueue对象queue，然后在for(,,)循环中调用queue.next取消息，当消息队列中没有消息时，就会阻塞在queue.next()这里。来看看queue.next()中做了什么：

Message next() {
    ... // 省略无关代码
        
    int nextPollTimeoutMillis = 0;
    for (;;) {
        if (nextPollTimeoutMillis != 0) {
            Binder.flushPendingCommands();
        }

        nativePollOnce(ptr, nextPollTimeoutMillis); // 休眠

        synchronized (this) {
            // Try to retrieve the next message.  Return if found.
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null; // 正常同步消息用不到这个
            Message msg = mMessages;
            // 当msg,target == null，表示这是同步屏障，msg就是优先执行的消息。
            if (msg != null && msg.target == null) {
                // Stalled by a barrier.  Find the next asynchronous message in the queue.
                do {
                    prevMsg = msg;
                    msg = msg.next; // 将同步屏障的异步消息放在队头，优先执行
                } while (msg != null && !msg.isAsynchronous());
            }
            
            // 主要看下面的代码
            if (msg != null) {
                // 代码片段1
                if (now < msg.when) {
                    // Next message is not ready.  Set a timeout to wake up when it is ready.
                    // 当前时间大于消息的时间，说明还没有到该消息执行的时候，计算出消息执行的延时时间
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                } else {
                    // 代码片段2
                    // Got a message.
                    mBlocked = false;
                    if (prevMsg != null) {
                        prevMsg.next = msg.next;
                    } else {
                        mMessages = msg.next; // msg将要进行处理，然后会将处理的消息删除，所以消息指针需要向后移一位
                    }
                    msg.next = null; // 表示将msg从消息队列中剔除
                    if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                    msg.markInUse();
                    return msg;
                }
            } else {
                // No more messages.
                nextPollTimeoutMillis = -1; // 没有消息，继续休眠等待
            }

            ... // 省略无关代码
        }

        ... // 省略无关代码
    }
}

next()里面是一个死循环，enqueueMessage()和next()方法中都用了同步锁，避免在发送消息时取消息以及取消息时发送消息，保证了线程安全。主要看synchronized(this)中的代码，首先获取到msg，就拿下图中发送的消息来看，此时的msg= mMessages = msg4，msg不为空，执行到<u>代码片段1</u>处，然后比较当前时间和msg.when的大小，如果now < msg.when，表明还没有到执行该消息的时候，计算出延迟执行时间；否则就执行<u>代码片段2</u>，prevMsg为空，所以执行mMessages = msg.next，将指针后移一位，即下图中的msg1处，然后执行msg.next = null，将msg4消息剔除。

在这里插入图片描述

这里要注意的是msg.next = null并不是将msg1设置为空的意思，而是将msg4与后面的消息节点断开连接。看下图

在这里插入图片描述

获取到消息之后会将消息返回，然后又回到了Looper.loop()方法的for(;;)中，返回的消息就是Message msg = queue.next();中的msg，然后将msg分发给handler处理，再次看上面的loop()方法，下面贴出关键代码：

try {
    msg.target.dispatchMessage(msg); // 分发处理消息
    if (observer != null) {
        observer.messageDispatched(token, msg); // 消息分发处理完成
    }
} catch (Exception exception) {
    ...
} finally {
    ...
}

调用到msg.target.dispatchMessage(msg)方法，那msg.hander是什么呢？其实它就是Handler，还记得handler.enqueueMessage()方法吗？

#Handler.java
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
        long uptimeMillis) {
    msg.target = this; // 在这里设置了target
    msg.workSourceUid = ThreadLocalWorkSource.getUid();

    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

总结

必须要先调用Looper.prepare()之后再调用Looper.loop()
消息队列中没有消息的时候会堵塞在next()方法处让CPU休眠，不会ANR
取到了消息后要判断当前时间和消息执行直接的先后关系，没到执行时间则继续休眠等待，否则就开始处理消息
处理消息前，会将该消息从消息队列中剔除
最后调用到handleMessage()方法处理消息（这条放在这里一起总结了）

处理消息

在Handler类中发送消息的时候就设置了msg.target，this指的就是当前的Handler对象。再次回到了Handler中，看看dispatchMessage做了什么事情。

public void dispatchMessage(@NonNull Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}

msg.callback是在创建Message的时候赋值的，而mCallback是在构造Handler的时候赋值的

public static Message obtain(Handler h, Runnable callback) {
    Message m = obtain();
    m.target = h;
    m.callback = callback; // 给msg.callback赋值

    return m;
}

public Handler() {
    this(null, false); // 默认callback为空
}

public Handler(@Nullable Callback callback, boolean async) {
    ... // 省略无关代码
    mQueue = mLooper.mQueue;
    mCallback = callback; // 给mCallback赋值，默认为空
    mAsynchronous = async;
}

因此msg.callback和mCallback都为空，接下来执行到handleMessage(msg)方法

public void handleMessage(@NonNull Message msg) {
}

handleMessage方法是一个空实现方法，具体的实现在Handler的回调中

Handler handler = new Handler() {
    @Override
    public void handleMessage(@NonNull Message msg) {
        super.handleMessage(msg);
        // 实现具体的逻辑
    }
};

扩展

从dispatchMessage()中处理消息的地方有三处，默认调用的就是handleMessage(msg)，那什么时候调用其它2种方式呢？

handleCallback(msg)

当msg.callback不为空就会执行handleCallback(msg)，那么就需要先给msg.callback赋值了。上面说过msg.callback是在创建Message的时候赋值的，创建Message是通过Message.obtain()来创建的，来看看obtain方法的重载方法：

public static Message obtain(){}
public static Message obtain(Message orig){}
public static Message obtain(Handler h){}
public static Message obtain(Handler h, Runnable callback){}
public static Message obtain(Handler h, int what){}
public static Message obtain(Handler h, int what, Object obj){}
public static Message obtain(Handler h, int what, int arg1, int arg2){}
public static Message obtain(Handler h, int what, int arg1, int arg2, Object obj){}

obtain有8个重载方法，第四个重载方法可以设置msg.callback，那在创建Message的时候可以这样写：

Handler handler = new Handler();
Message message = Message.obtain(handler, new Runnable() {
    @Override
    public void run() {
    }
});
handler.sendMessage(message); // 发送消息

在Message obtain(handler, callback)中对msg.callback进行了赋值

public static Message obtain(Handler h, Runnable callback) {
    Message m = obtain();
    m.target = h;
    m.callback = callback; // 赋值
    return m;
}

然后在分发消息时会执行到handleCallback(msg)

private static void handleCallback(Message message) {
    message.callback.run();
}

最终会回调到创建Message时传入的第二个参数Runnable的run方法中。

mCallback.handleMessage(msg)

msg.callback的优先级最高，其次是mCallback，只有在msg.callback为空时才会执行到mCallback.handleMessage(msg)，所以在创建Message的时候不能再传入callback了。mCallback是在构造Handler的时候赋值的，所以要在创建Handler的时候就要传入mCallback。来看看Handler的构造函数：

public Handler(){}
public Handler(@NonNull Looper looper){}
public Handler(@NonNull Looper looper, @Nullable Callback callback){}
public Handler(boolean async){}
public Handler(@Nullable Callback callback){}
public Handler(@Nullable Callback callback, boolean async){} // @hide
public Handler(@NonNull Looper looper, @Nullable Callback callback, boolean async){}

Handler有7个构造函数，我们可以通过最简单的第五个构造函数来创建Handler：

Handler handler = new Handler(new Handler.Callback() {
    @Override
    public boolean handleMessage(@NonNull Message msg) {
        return false;
    }
});
Message message = Message.obtain(handler);
handler.sendMessage(message);

在Handler的构造函数中对mCallback进行了赋值，最终会调用到第六个被标上@hide的构造函数：

public Handler(@Nullable Callback callback, boolean async) {
    ... // 省略无关代码
    mQueue = mLooper.mQueue;
    mCallback = callback; // 赋值
    mAsynchronous = async;
}

此时，msg.callback为空，mCallback不为空，就会调用mCallback.handleMessage(msg)方法，最后回调到了创建Handler的参数Handler.Callback的handleMessage(msg)中。

Handler机制源码详解

流程介绍

源码解析

发送消息

总结

取出消息

总结

处理消息

扩展

猜你喜欢

热点阅读