android looper 机制

在android中，我们会经常使用到Handler，Message，Looper和MessageQueue，因为它们之间的联系已经被封装好了，所以对于上层来说我们只知道使用Handler，Message就可以了。对于只关注应用开发而言，可以理所当然地这么认为，但是我们最好还是了解下面的运作机制。

首先我们从创建一个HandlerThread开始

在这个过程中我们需要重点了解 thread和looper是怎么绑定的？

一个thread对象只能和一个looper做绑定，在prepare()的时候做的绑定，其实就是把 thread对象和一个looper对象当作 <key,value>放到ThreadLocal (一个类似于map的数据结构) 中，这是一个静态的变量。

// sThreadLocal.get() will return null unless you've called prepare().
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

     /** Initialize the current thread as a looper.
      * This gives you a chance to create handlers that then reference
      * this looper, before actually starting the loop. Be sure to call
      * {@link #loop()} after calling this method, and end it by calling
      * {@link #quit()}.
      */
    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));
    }

然后进入Looper.loop() 循环中，等待事件触发或者超时，jni层的looper用到了epoll ，怎么理解epoll呢？

int Looper::pollInner(int timeoutMillis) {
   ...
    // We are about to idle.
    mPolling = true;

    struct epoll_event eventItems[EPOLL_MAX_EVENTS];
    int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);

    // No longer idling.
    mPolling = false;
    ...
 ｝

具体的实现讲起来比较复杂，这里只介绍它的作用，上面的流程图中，我们看到loop函数最终会阻塞在pollInner()函数，而这个函数里面最关键的是epoll_wait(),

第一个参数mEpollFd是由epoll_create()创建出来的fd，它可能关联了其他fd，可以把它当作fd集合，第二参数和第三个三个参数不介绍，第四个参数是等待超时的时间，

如果参数是-1就会一直等到mEpollFd可读。所以epoll_wait()的作用就是如果监听的fd集合(mEpollFd)可读（或者有变化）时，就会有返回，否则等待timeoutMillis的时间后返回，如果参数是-1就会一直等待。

接下来我们看一下Handler sendMessage过程

我们先了解一下Handler是怎么和Lopper绑定的吧

前面介绍了，创建HandlerThread，把它run()起来后，就会把thread和looper绑定起来，所以通过HandlerThread就可以拿到绑定的looper对象，如果使用了Handler无参构造函数，那是怎么获取looper对象的呢？

  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()");
        }
       ...
   }

 /**
     * 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();
    }

原来是通过sThreadLocal这个静态对象，这里用到了TLS ，不过多介绍，这里的作用就是拿到当前线程绑定的looper对象，如果是在另外的线程创建Handler，那就是拿另外一个线程绑定的looper对象，同理，我们在app的主线程中创建handler对象，用的就是主线程的looper对象。

handler 调用sendMessage后，会把Message插入MessageQueue中，我们重点关注一下新来的message是怎么插入的。

  boolean enqueueMessage(Message msg, long when) {
      ...
        synchronized (this) {
            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;
            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;
                for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {//如果已经到尾部，或者设定的执行时间比新来message的执行时间长，就是要插入的位置
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        needWake = false;
                    }
                }
                msg.next = p; // invariant: p == prev.next
                prev.next = msg;
            }

            // We can assume mPtr != 0 because mQuitting is false.
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

从这里我们可以知道MessageQueue中使用了链表的形式保存Message，Message中的next属性指向下一个message。

 if (p == null || when == 0 || when < p.when) 这三个条件分别表示链表中没有Message，或者新来的Message需要马上执行（when == 0），或者新来的Message需要最早执行，则插入链表的头部；否则遍历链表，按照Message设定的执行时间插入到对应的位置。

最后，我们再把Handler.sendMessage() 到Handler.handleMessage() 的过程叙述一遍。

首先Handler会把Message插入到MessageQueue中

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

Message的target被设置成发送此Message的Handler对象，Message插入MessageQueue后，queue.next()会取出接下来要处理的Message，如果delay时间是0，epoll_wait()基本马上就返回，所以就从链表中取出了要处理的Message（放在链表头部的message）。

 /**
     * 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();
        final MessageQueue queue = me.mQueue;
        ...
        for (;;) {
            Message msg = queue.next(); // might block
            try {
                msg.target.dispatchMessage(msg);
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
         ...
        }
    }

取出要处理的Message后，会调用到 msg.target.dispatchMessage(); 这个target就是上面发送Message的Handler对象，如果没有处理Message的callback，就交给Handler.handleMessage()函数处理。

/**
     * 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);
        }
    }

到此，这个流程分析完毕。