要想在一个线程要想使用消息循环系统,通常需要:

Looper.prepare();
mHandler = new Handler() {...};
Looper.loop();

而在 UI 线程直接创建 Handler 实例就可以直接使用(通过Handler 的无参构造函数创建的 Handler 默认与当前线程的 Looper 绑定),是因为在 ActivityThread 中的 main() 方法中,系统已为我们自动创建好了 Looper 并调用了 loop() 方法开启了循环:

public static void main(String[] args) {
    ...
    Looper.prepareMainLooper();
	...
    Looper.loop();
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

Looper.prepareMainLooper(); 实际上就是调用了 Looper 的 prepare() 方法,之所以系统弄了一个 prepareMainLooper()方法是因为系统在给 UI 线程创建 Looper 实例的时候顺便把这个实例赋值给了 Looper 的一个内部静态变量 sMainLooper:

private static Looper sMainLooper;

并且提供了一个静态方法 getMainLooper() 供外部调用来获取这个 sMainLooper,方便在其他线程中可随时拿到 UI 线程的 Looper,一旦拿到 UI 线程的 Looper,我们就可以在其他线程很方便地创建一个与 UI 线程中的 Looper 相关联的 Handler 了,例如下面这样:

Handler handler = new Handler(Looper.getMainLooper){...};

一、一个线程中只有一个 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));
}

二、一个 Looper 内部维护了一个 MessageQueue 消息队列

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

Handler 负责发送 Message 消息到与之绑定的线程中 Looper 中的 MessageQueue

Handler 的各种 sendMessage() 方法最后都会辗转来到 Handler 的 enqueueMessage() 方法,在内部调用了与 Handler 相绑定线程的 Looper 内部的 MessageQueue 的 enqueueMessage() 来将消息放进消息队列中。

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

三、Looper 的作用就是循环取出 MessageQueue 中的 Message 并返交给发送它的 Handler 去处理

Looper.loop() 调用后即开启了循环系统:

public static void loop() {
	...
    for (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }
      	...
        try {
            msg.target.dispatchMessage(msg);
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }
		...
    }
}

Looper 不断的从 MessageQueue 队列中取出消息并调用了消息的 target.dispatchMessage(msg) 方法,Message 的 target 一般为发送消息的 Handler (上面 Handler enqueueMessage()的代码块中有体现 msg.target = this ),Handler 的 dispatchMessage() 方法就是对消息的处理了,

/**
 * Handle system messages here.
 */
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();
}

可以看到,会优先把消息交给 Message 的 callback (一个 Runnable) 的 run() 方法处理,如果 callback 为空就会再尝试给 Handler 的 callback(mCallback) 处理,如果 Handler 的 callback 也为空,就会给 Handler 我们熟知的 handleMessage() 方法处理。

四、一个线程中可以有多个 Handler,但一个 Handler 只能与一个 Looper 绑定