Android Looper机制简介

一、主线程和Looper

我们知道android中可以使用Handler向主线程发送消息，来实现线程间的异步通信，AsyncTask内部其实也是使用Handler实现的。

主线程之所以可以接收Handler消息，是因为主线程在启动时，已经创建了Looper对象。

/*** ActivityThread.java ***/
public static void main(String[] args) {
    Looper.prepareMainLooper();

    ActivityThread thread = new ActivityThread();
    thread.attach(false);

    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }
    Looper.loop();
}

二、工作线程使用Looper

而我们如果直接创建一个线程，是无法接收Handler的消息的，需要为该线程创建一个Looper对象才可以。
创建带有Looper的线程的方法如下：

class LooperThread extends Thread {
    public Handler mHandler;

    public void run() {
        Looper.prepare();

        mHandler = new Handler() {
            public void handleMessage(Message msg) {
                // process incoming messages here
            }
        };

        Looper.loop();
    }
}

实际上，主线程的Looper创建，和上面的过程是一样一样的。
下面根据这个过程，简单介绍一下Android的Looper机制。

三、Looper机制简介

Android应用程序是通过消息来驱动的，每一个拥有Looper的线程（如主线程），都有一个消息队列，其他线程向消息队列里放入消息，Looper线程不断循环地从消息队列里取出消息并处理。没有消息可处理时，Looper线程就进入阻塞状态，直到有新的消息需要处理时被唤醒。

四、代码位置

基于Android6.0的代码
涉及到的类的代码位置

frameworks/base/core/java/android/os/Handler.java
frameworks/base/core/java/android/os/Message.java
frameworks/base/core/java/android/os/MessageQueue.java
frameworks/base/core/java/android/os/Looper.java

frameworks/base/core/jni/android_os_MessageQueue.cpp

system/core/libutils/Looper.cpp

五、Looper.java简化

package android.os;

public final class Looper {

    //为每一个线程维护一个Looper
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    //主线程Looper，每个进程只有一个
    private static Looper sMainLooper;
    //Looper的消息队列
    final MessageQueue mQueue;
    //Looper所在的线程
    final Thread mThread;

    public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        //同一个线程不能重复创建Looper
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

    //创建主线程Looper，由系统调用
    public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }

    /**
     * Returns the application's main looper, which lives in the main thread of the application.
     */
    public static Looper getMainLooper() {
        synchronized (Looper.class) {
            return sMainLooper;
        }
    }

    /**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the 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;

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

            msg.target.dispatchMessage(msg);

            msg.recycleUnchecked();
        }
    }

    /**
     * Return the Looper object associated with the current thread.  Returns
     * null if the calling thread is not associated with a Looper.
     */
    public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

    /**
     * Return the {@link MessageQueue} object associated with the current
     * thread.  This must be called from a thread running a Looper, or a
     * NullPointerException will be thrown.
     */
    public static @NonNull MessageQueue myQueue() {
        return myLooper().mQueue;
    }

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

    //直接退出，回收消息队列里所有的消息
    public void quit() {
        mQueue.quit(false);
    }

    //处理完当前的消息，回收消息队列里要在将来某个时刻处理的消息
    public void quitSafely() {
        mQueue.quit(true);
    }

    /**
     * Gets the Thread associated with this Looper.
     *
     * @return The looper's thread.
     */
    public @NonNull Thread getThread() {
        return mThread;
    }

    /**
     * Gets this looper's message queue.
     *
     * @return The looper's message queue.
     */
    public @NonNull MessageQueue getQueue() {
        return mQueue;
    }
}

六、Looper的初始化流程

1.Looper.prepare()

调用Looper.prepare()会new一个Looper对象，Looper的构造函数中，又会new一个消息队列MessageQueue。

/*** MessageQueue.java ***/
MessageQueue(boolean quitAllowed) {
    mQuitAllowed = quitAllowed;
    mPtr = nativeInit();
}

通过JNI机制，MessageQueue调用nativeInit()函数，在JNI层创建一个NativeMessageQueue对象，并将该对象的句柄保存在mPtr变量中。代码如下

/*** android_os_MessageQueue.cpp ***/
static jlong android_os_MessageQueue_nativeInit(JNIEnv* env, jclass clazz) {
    NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue();
    if (!nativeMessageQueue) {
        jniThrowRuntimeException(env, "Unable to allocate native queue");
        return 0;
    }

    nativeMessageQueue->incStrong(env);
    return reinterpret_cast<jlong>(nativeMessageQueue);
}

NativeMessageQueue初始化时又会创建一个native层的Looper对象。

/*** android_os_MessageQueue.cpp ***/
NativeMessageQueue::NativeMessageQueue() :
        mPollEnv(NULL), mPollObj(NULL), mExceptionObj(NULL) {
    mLooper = Looper::getForThread();
    if (mLooper == NULL) {
        mLooper = new Looper(false);
        Looper::setForThread(mLooper);
    }
}

native层的Looper和java层的Looper是对应的，主要负责唤醒java层的Looper，后面会讲到唤醒原理。

2.mHandler = new Handler()

Handler有多个构造方法，主要分为两类，一类带有Looper参数，构造时可以直接把Looper对象传进去；另一类不带Looper参数，这一类构造会调用到下面这个隐藏的构造方法。

/*** Handler.java ***/
public Handler(Callback callback, boolean async) {
    mLooper = Looper.myLooper();
    if (mLooper == null) {
        throw new RuntimeException(
            "Can't create handler inside thread that has not called Looper.prepare()");
    }
    mQueue = mLooper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

由上面的代码可知，
new Handler之前必须调用Looper.prepare()初始化Looper对象（主线程的Looper由系统初始化），否则会抛异常。
new Handler不带Looper参数时，Handler默认获取当前线程的Looper，即由哪个线程创建的Handler，发消息时，就是哪个线程来处理消息。
Handler对象还得到了Looper对应的消息队列。

3.Looper.loop()

调用Looper.loop()开启消息循环。loop()的主要逻辑如下

/*** Looper.java ***/
public static void loop() {
    //获取当前线程的Looper对象
    final Looper me = myLooper();
    //获取Looper对象的消息队列
    final MessageQueue queue = me.mQueue;

    for (;;) {
        //循环从消息队列中获取消息
        //消息队列中没有消息，或者都是若干时间后才要处理的消息，就会阻塞在这里
        //等有新的需要马上处理的消息或者到时间后，就会取出消息继续执行。
        Message msg = queue.next();

        //从消息队列取出消息后分发处理
        msg.target.dispatchMessage(msg);

        //处理完消息后回收消息对象
        msg.recycleUnchecked();
    }
}

可以看出，Looper.loop()是一个循环，其后面的代码一般不会执行，除非调用了Looper的quit方法退出消息循环。
初始化完成，由于消息队列里还没有消息，所以线程阻塞在queue.next()等待被唤醒。

七、为何阻塞在queue.next()

/*** MessageQueue.java ***/
Message next() {
    //mPtr指向NativeMessageQueue对象
    final long ptr = mPtr;
    if (ptr == 0) {
        return null;
    }

    int nextPollTimeoutMillis = 0;
    for (;;) {
        if (nextPollTimeoutMillis != 0) {
            //不知道是干啥的
            Binder.flushPendingCommands();
        }

        nativePollOnce(ptr, nextPollTimeoutMillis);

        synchronized (this) {
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;
            if (msg != null) {
                if (now < msg.when) {
                    //下个消息还没有准备好，需要延时处理
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                } else {
                    // Got a message.
                    if (prevMsg != null) {
                        prevMsg.next = msg.next;
                    } else {
                        mMessages = msg.next;
                    }
                    msg.next = null;
                    if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                    msg.markInUse();
                    //取出消息，并从消息队列移除
                    return msg;
                }
            } else {
                // No more messages.
                nextPollTimeoutMillis = -1;
            }

            // Process the quit message now that all pending messages have been handled.
            if (mQuitting) {
                dispose();
                return null;
            }
        }

        // Run the idle handlers.
        // 省略了 idle handlers 的相关处理

        // While calling an idle handler, a new message could have been delivered
        // so go back and look again for a pending message without waiting.
        nextPollTimeoutMillis = 0;
    }
}

nativePollOnce(ptr, nextPollTimeoutMillis);这个函数最终会调用到native Looper的pollnce()函数

/*** Looper.cpp ***/
Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
    int result = 0;
    for (;;) {
        //...
        if (result != 0) {
            //...
            return result;
        }

        result = pollInner(timeoutMillis);
    }
}

pollInner这个函数比较长，而且涉及到了Linux的epoll系统调用接口和管道等概念，这里不做介绍，只截取了部分代码，如下

/*** Looper.cpp ***/
int Looper::pollInner(int timeoutMillis) {
    //这里就是等待消息，真正阻塞的地方！！！
    int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);

    //some error
    if (eventCount < 0) {
        result = POLL_ERROR;
        goto Done;
    }

    //没有新消息，超时唤醒。
    //说明消息队列里有delay的消息到时间该处理了。
    if (eventCount == 0) {
        result = POLL_TIMEOUT;
        goto Done;
    }

    for (int i = 0; i < eventCount; i++) {
        int fd = eventItems[i].data.fd;
        uint32_t epollEvents = eventItems[i].events;
        if (fd == mWakeEventFd) {
            if (epollEvents & EPOLLIN) {
                awoken();
            } else {
                ALOGW("Ignoring unexpected epoll events 0x%x on wake event fd.", epollEvents);
            }
        } else {
            //......
        }
    }
}

总之，有新消息到来或超时唤醒时，都会从这个函数中返回到MessageQueue.next()函数中的nativePollOnce(ptr, nextPollTimeoutMillis)处，继续往下执行。
如果有消息需要马上处理（now >= msg.when），则返回到Looper.loop()中，进行消息分发处理，处理完后回收该消息。
否则更新超时时间，循环继续进入nativePollOnce(ptr, nextPollTimeoutMillis)等待。

八、何时被唤醒

上面说了，有新消息到来或超时时间到时，epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis)可以被唤醒。
有超时时间，说明已经有延时消息被发过来了，只是没有马上处理。那么什么时候会有消息发过来呢？
先来看一下java层消息的发送流程。

九、java层消息发送流程

发送消息有以下几种方法：
1.使用Message的sendToTarget()：会调用Handler的sendMessage(Message msg)方法
2.使用Handler的sendXXX系列和postXXX系列：

sendMessage(Message msg)
sendMessageDelayed(Message msg, long delayMillis)
sendMessageAtTime(Message msg, long uptimeMillis)

sendEmptyMessage(int what)
sendEmptyMessageDelayed(int what, long delayMillis)
sendEmptyMessageAtTime(int what, long uptimeMillis)

post(Runnable r)
postDelayed(Runnable r, long delayMillis)
postAtTime(Runnable r, long uptimeMillis)

//下面两个方法会将Message插入到消息队列的最前端
sendMessageAtFrontOfQueue(Message msg)
postAtFrontOfQueue(Runnable r)

以上函数最终都会调用到下面的函数，将Message放到消息队列里去。

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

/*** MessageQueue.java ***/
boolean enqueueMessage(Message msg, long when) {
    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.next = p;
            mMessages = msg;
            needWake = mBlocked;
        } else {
            needWake = mBlocked && p.target == null && msg.isAsynchronous();
            Message prev;
            //循环遍历队列里的消息，按处理时间先后顺序，将新消息插入到合适位置
            for (;;) {
                prev = p;
                p = p.next;
                if (p == null || when < p.when) {
                    break;
                }
                if (needWake && p.isAsynchronous()) {
                    needWake = false;
                }
            }
            msg.next = p;
            prev.next = msg;
        }
        //注意了注意了 wake wake
        if (needWake) {
            nativeWake(mPtr);
        }
    }
    return true;
}

需要说明的是，msg.when变量表示该消息在什么时间点（系统启动时间 SystemClock.uptimeMillis()）处理。
Message在消息队列里是按msg.when排序的，需要先执行的会放队列前面。
将Message插入到消息队列后，如需wake，就会调用nativeWake(mPtr)函数。
那什么情况下需要wake呢？

synchronization barrier 同步分割栏

首先来了解一下什么是synchronization barrier。
（见MessageQueue的postSyncBarrier()方法和removeSyncBarrier(int token)方法。）
在Message中有同步消息和异步消息之分。
（见Message的setAsynchronous(boolean async)方法和isAsynchronous()方法）
同步分割栏也是一个Message类型的对象，只不过它的target为空，如上面代码中p.target == null就代表p是一个同步分割栏。
简单的说，如果消息队列里没有同步分割栏，同步和异步消息是没有区别的。
如果队列里有同步分割栏，则其后面的同步消息，即使时间到了，也不会被执行，除非同步分割栏被移除。而异步消息则不会受此限制。

把消息插入到消息队列时，以下两种情况才需要唤醒。
一种情况是，新消息插入队首。
另一种情况是，队首是一个同步分割栏，而新插入的消息之前没有异步消息。

其他情况说明消息队列中的消息正在被处理，或者新消息前有等待处理的消息，新消息的处理时间还没到，则不需要唤醒。

十、唤醒

/*** MessageQueue.java ***/
nativeWake(mPtr);

/*** android_os_MessageQueue.cpp ***/
static void android_os_MessageQueue_nativeWake(JNIEnv* env, jclass clazz, jlong ptr) {
    NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
    nativeMessageQueue->wake();
}

/*** android_os_MessageQueue.cpp ***/
void NativeMessageQueue::wake() {
    mLooper->wake();
}

/*** Looper.cpp ***/
void Looper::wake() {
    uint64_t inc = 1;
    ssize_t nWrite = TEMP_FAILURE_RETRY(write(mWakeEventFd, &inc, sizeof(uint64_t)));
    if (nWrite != sizeof(uint64_t)) {
        if (errno != EAGAIN) {
            ALOGW("Could not write wake signal, errno=%d", errno);
        }
    }
}

涉及到了Linux的epoll系统调用接口和管道等概念，不做介绍，有兴趣可以自行查阅资料。
这里往文件里写如内容，前面就会监听到，从而Looper::pollInner(int timeoutMillis)函数中的epoll_wait()函数就返回了。
到此唤醒Looper线程。

十一、分发消息

Looper线程唤醒后，从消息队列取出消息，然后进行分发处理。

msg.target.dispatchMessage(msg);

Message的成员变量target就是要处理该Message的目标Handler，消息分发函数如下

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

前面说了，发送消息使用Handler的sendXXX方法和postXXX方法。
上面msg.callback是使用Handler的postXXX方法发送消息时的参数Runnable，
若使用postXXX方法发送消息，则分发消息时，调用该Runnable的run()函数处理消息。
若使用sendXXX方法发送消息，则分发消息时，调用Handler的handleMessage(Message)函数处理消息。

十二、总结

简单总结一下：java层和native层各有一个Looper。
java层Looper：维护一个消息队列，不断循环从消息队列中取消息并处理。队列中没有消息时等待，其他线程将消息插入消息队列后，Looper并不是马上取出消息处理，而是等待唤醒。
native层Looper：与java层的对应，使用Linux的epoll系统调用，监听事件发生（文件有内容写入），唤醒java层Looper。
消息队列：中的消息是按处理时间排序。
其他线程将消息插入到消息队列中，然后根据需要，调用native接口唤醒java层Looper处理消息。
对于延时消息，由MessageQueue计算延时时间，利用epoll_wait的超时机制，超时唤醒。

十三、参考

Android Looper类代码分析（含 epoll系统调用接口简介）

Looper中的睡眠等待与唤醒机制（native Looper）

Android应用程序消息处理机制（Looper、Handler）分析