Handler源码解析

本文为作者原创，转载请注明链接

Handler的运行机制是Android程序员面试中经常被问到的一个问题，因为该问题可以考察面试者对于Android源码的了解程度。本文将以源码的角度来探索Handler的机制和原理。

Handler消息处理机制

这张图是本人画的，下面通过绑定Looper和MessageQueue、发送消息、处理消息三个步骤来解析Handler的源码。

Looper.prepare()和Looper.loop()方法

要在某一个线程中使用Handler接受处理消息，必须在该线程中执行这两个方法。那为什么我们平时好像没有调用过着两个方法呢？那是因为Android主线程已经帮我们调用了这两个方法。例如要在子线程中使用Handler接收处理消息，就需要我们自己手动调用这两个方法了。在本文中只讨论在主线程中使用Handler接受处理消息的情况(在子线程的情况也是一样的)。

先来看看Looper.prepare()和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));
}

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

可以看到在这段源码中，new了一个Looper对象保存到了sThreadLocal中。那么ThreadLocal又是什么东西呢？ThreadLocal是一个线程内部的数据存储类，这里不展开介绍它。简单来说ThreadLocal可以根据不同的线程保存和读取不同的数据，由于Handler使用的时候就是多线程的情景，在这里使用ThreadLocal来保存主线程中的Looper对象再合适不过了。而在Looper的构造函数中，new了一个MessageQueue并赋值给成员变量mQueue，即为该Looper对象绑定了一个MessageQueue。

那么这段代码总结起来，它的目的就是在为主线程创造并绑定一个Looper对象，并为该Looper对象绑定一个MessageQueue对象。

下面再来看看Looper.loop()方法做了什么事：

public static void loop() {
    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;

    Binder.clearCallingIdentity();
    final long ident = Binder.clearCallingIdentity();

    for (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }
        ......
    }
}

这段源码就比较长了，没关系我们只看重点。

首先通过myLooper()方法拿到looper对象，然后通过该对象拿到MessageQueue对象queue。下面使用Binder和底层通信，这里不展开。

重点在于下面的无限for循环。for (;;)非常简单粗暴，调用了MessageQueue的next()方法。后面的注释提示了这个方法可能会阻塞。如果返回的消息为null，代表MessageQueue已退出，return退出loop()方法。如果MessageQueue中没有消息对象，next()方法会阻塞，直到再有消息传进来。

Handle发送消息方法

Handle的sendMessage方法最终调用的是sendMessageAtTime方法，来看看这个方法干了什么：

public boolean sendMessageAtTime(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);
}

很简单，先判断有没有绑定的MessageQueue对象，如果没有就要抛异常。有的话执行enqueueMessage方法。

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

msg.target这个成员变量就是Hanlder类，赋值为this代表，把消息发给调用这个方法的Handler。然后执行queue.enqueueMessage方法。这个方法将消息加进MessageQueue中，如果原来的MessageQueue中没有消息，会唤醒它执行next()方法取消息。具体的源码涉及native层的操作，在这里就不展开讨论了，有兴趣的朋友可以研究下。

如果是用post(Runnable r)方法发消息呢？

public final boolean postAtTime(Runnable r, long uptimeMillis) {
    return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}

private static Message getPostMessage(Runnable r) {
    Message m = Message.obtain();
    m.callback = r;
    return m;
}

可以看到最终调用的还是sendMessageAtTime方法，只是通过getPostMessage方法把runnable对象放进一个消息对象传出去。

Handler处理消息

通过上面的流程，消息发出来了，进入MessageQueue中，我们在主线程又通过Looper.loop()方法把消息取出来了，那下面怎么处理消息呢？继续来看Looper.loop()方法，取出消息后有这么一段代码：

try {
    msg.target.dispatchMessage(msg);
} finally {
    if (traceTag != 0) {
        Trace.traceEnd(traceTag);
    }
}

msg.target是什么？不就是上面enqueueMessage方法中，我们传人的handle对象嘛。也就是说这里调用了handle对象的dispatchMessage(msg)方法来处理消息，继续看该方法：

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

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

首先判断消息中的callback是否为空，如果post(Runnable r)发来的消息，这里的callback就是传来的runnable对象了，调用handleCallback(msg)处理。这个方法就简单了，直接运行该runnable即可。

callback对象为空，会判断mCallback是否为空。这里的mCallback对象是Handler构造函数中传进来的，是Hanlder中的内部接口。如果有就回调接口实现的handleMessage(msg)方法。没有的话，调用handleMessage(msg)方法。该方法默认什么都不做，一般是我们自己重写该方法处理消息。

总结

至此，Handler发送消息，取消息，处理消息的流程我们已经从源码的角度剖析完成了。下次面试再被问到就可以游刃有余地回答了。MessageQueue中的next()和enqueueMessage方法涉及到很多native方法，在本文中没有展开研究，有兴趣的朋友可以把这部分也搞明白了，对Handler机制会有一个更深的理解。

Handler源码解析

Looper.prepare()和Looper.loop()方法

Handle发送消息方法

Handler处理消息

总结

你可能感兴趣的:(Handler源码解析)