概述

Android是一个消息驱动的系统，Android的四大组件Activity, Service, ContentProvider, BroadcastReceiver的交互过程都离不开消息机制。
Java层的消息机制主要由以下4个类来实现

• Message：消息分为硬件产生的消息(如按钮、触摸)和软件生成的消息；
• MessageQueue：消息队列的主要功能向消息池投递消息(MessageQueue.enqueueMessage)和取走消息池的消息(MessageQueue.next)；
• Handler：消息辅助类，主要功能向消息池发送各种消息事件(Handler.sendMessage)和处理相应消息事件(Handler.handleMessage)；
• Looper：不断循环执行(Looper.loop)，按分发机制将消息分发给目标处理者。

类结构图如下

Main.jpg

Handler的简单使用方法如下，可以用于线程间通信

  //在主线程中初始化Handler
  private Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
                switch(msg.what){
                //在此处处理消息
                }
        }
    };


 Thread thread = new Thread(){
            @Override
            public void run() {
                super.run();
                //在子线程中发送消息
                Message msg = new Message();
                msg.what = 1;
                handler.sendMessage(msg);
            }
        };
  thread.start();

由代码可见从子线程发送消息到主线程需要三步

• 1: 在主行程创建Handler对象，并实现handleMessage(Message msg)方法
• 2: 创建Message对象
• 3: 在子线程中使用handler对象的sendMessage方法发送消息

其实在创建Handler对象的时候，所在的线程必须先执行Looper.prepare()和Looper.loop()两个方法， 由于我们在Android创建Handler的时候一般是在Android的主线程中创建的，可以省略这个步骤， 因为Android的主线程在创建的时候已经为我们做了这些事情， 这也是主线程之所以称之为主线程的意义。
以下是ActivityThread.main方法代码

public static void main(String[] args) {
        Looper.prepareMainLooper();
        ActivityThread thread = new ActivityThread();
        thread.attach(false, startSeq);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

Looper.prepareMainLooper方法和Looper.prepare方法类似， 只不过前者是专门为主线程实现的方法。

Looper初始化过程

如果想要在一个线程中创建Handler对象，必须在该线程中调用Looper.prepare()和Looper.loop()两个方法初始化，这两个方法究竟做了哪些准备呢？

Looper.prepare

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

这个方法非常简单，只是调用了带参数的prepare方法，带参数的prepare又做了什么工作呢？创建了一个Looper对象，并将它存储到了线程本地内存中， 也就是说Looper是某个线程独有的。
这个方法的的作用是为本线程初始化Looper, 初始化Looper之后，就可以在本线程中创建Handler了。

Looper构造方法

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

Looper的构造方法中创建了一个MessageQueue对象，并且保存在了当前线程的Looper对象中，MessageQueue中保存了Java层的Message消息队列。

MessageQueue构造方法

private long mPtr; // used by native code
  MessageQueue(boolean quitAllowed) {
        mQuitAllowed = quitAllowed;
        mPtr = nativeInit();
    }

MessageQueue对象的构造方法中调用nativeInit方法初始化了mPtr变量，该变量中保存了一个C++对象的指针地址。
nativeInit是一个native方法， 通过JNI调用，具体实现在/frameworks/base/core/jni/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);
}

通过该方法的实现可以看出，native层创建了一个NativeMessageQueue对象， 并将该对象的指针返回给了Java层，最终保存在了Java层MessageQueue对象的mPtr变量中， 也就是说一个Java层的MessageQueue对象对应了一个Natvie层的NativeMessageQueue对象。那NativeMessageQueue的作用是什么呢？

NativeMessageQueue

NativeMessageQueue::NativeMessageQueue() {
    mLooper = Looper::getForThread();
    if (mLooper == NULL) {
        mLooper = new Looper(false);
        Looper::setForThread(mLooper);
    }
}

在NativeMessageQueue中， 首先调用getForThread方法从线程本地内存中获取Native的Looper对象，如果没有， 则创建一个新的Native Looper对象，同样保存到现场本地内存中，和Java层的ThreadLocal类似。

Native Looper构造方法

Looper::Looper(bool allowNonCallbacks) :
        mAllowNonCallbacks(allowNonCallbacks), mSendingMessage(false),
        mPolling(false), mEpollFd(-1), mEpollRebuildRequired(false),
        mNextRequestSeq(0), mResponseIndex(0), mNextMessageUptime(LLONG_MAX) {
    mWakeEventFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
    LOG_ALWAYS_FATAL_IF(mWakeEventFd < 0, "Could not make wake event fd: %s",
                        strerror(errno));

    AutoMutex _l(mLock);
    rebuildEpollLocked();
}

Native的Looper主要使用了Linux的Epoll机制，eventfd 是 Linux 的一个系统调用，创建一个文件描述符用于事件通知, 创建的文件描述符保存在mWakeEventFd变量中。
然后调用rebuildEpollLocked方法创建Epoll监听事件

void Looper::rebuildEpollLocked() {
    // 如果Epoll已经创建，则先关闭
    if (mEpollFd >= 0) {
#if DEBUG_CALLBACKS
        ALOGD("%p ~ rebuildEpollLocked - rebuilding epoll set", this);
#endif
        close(mEpollFd);
    }

     // 创建一个 epoll 的句柄，EPOLL_SIZE_HINT 是指监听的描述符个数
    // 现在内核支持动态扩展，该值的意义仅仅是初次分配的 fd 个数，后面空间不够时会动态扩容。
    // 当创建完 epoll 句柄后，占用一个 fd 值.
    mEpollFd = epoll_create(EPOLL_SIZE_HINT);
    LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance: %s", strerror(errno));

    struct epoll_event eventItem;
    memset(& eventItem, 0, sizeof(epoll_event)); // zero out unused members of data field union
    eventItem.events = EPOLLIN;
    eventItem.data.fd = mWakeEventFd;
    //对 mWakeEventFd 文件描述符进行注册，这样 mEpollFd 就能监听到 mWakeEventFd 的读写事件。
    int result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeEventFd, & eventItem);
    LOG_ALWAYS_FATAL_IF(result != 0, "Could not add wake event fd to epoll instance: %s",
                        strerror(errno));

    //设置要监听的其他fd
    for (size_t i = 0; i < mRequests.size(); i++) {
        const Request& request = mRequests.valueAt(i);
        struct epoll_event eventItem;
        request.initEventItem(&eventItem);

        int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, request.fd, & eventItem);
        if (epollResult < 0) {
            ALOGE("Error adding epoll events for fd %d while rebuilding epoll set: %s",
                  request.fd, strerror(errno));
        }
    }
}

rebuildEpollLocked方法创建了Epoll句柄, 并设置了Epoll监听mWakeEventFd文件节点的可读事件，当mWakeEventFd有新内容的时候触发事件。同时还设置了Epoll还可以监听其他文件描述符，此处Native Looper的用法，不再详细分析。Native Looper和Java层的Looper虽然名字一样， 但是两者没有关系，Android在Java层和Native层分别实现了一套Handler消息机制。

Looper.prepare到底做了什么工作呢？
为调用线程创建了一个Looper对象，保存在了线程本地内存中，为该线程独有，Looper对象中创建并保存了一个MessageQueue对象，这个Java层的MessageQueue对象对应了一个NativeMessageQueue对象。而NativeMessageQueue对象初始化了Epoll, 监听mWakeEventFd文件节点。

Looper.loop

/**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
    public static void loop() {
        // 找到本线程的Looper对象
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        拿到Looper中的MessageQueue对象
        final MessageQueue queue = me.mQueue;

        // 无限循环遍历
        for (;;) {
            //调用MessageQueue.next方法获取下一个message,如果没有消息会阻塞在这个方法上
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

            final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;
            final long dispatchEnd;
            try {
                // 调用Message.target的dispatchMessage方法处理消息
                // target就是Handler, 后续在详细分析
                msg.target.dispatchMessage(msg);
                dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            msg.recycleUnchecked();
        }
    }

Looper.loop方法做了以下几个事情：
1: 调用myLooper方法，从线程本地内存中取出该线程的Looper对象，然后从Looper对象中拿出MessageQueue对象
2: 调用MessageQueue的next方法获取下一个Message消息，如果没有消息就阻塞在该方法上
3: 将获取的Message消息，通过target的dispatchMessage方法进行处理
循环执行步骤2和步骤3

那我们看下MessageQueue的next方法是如何处理的？

Message next() {

        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        int nextPollTimeoutMillis = 0;
        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
            }

            // 调用Native的方法，可能阻塞在此方法上
            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;
        
                if (msg != null) {
                    if (now < msg.when) {
                        // 下一个Message还不到触发事件，计算距离出发时所剩的时间，设置为下次触发时间
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        // Got a message.
                        mBlocked = false;
                        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 {
                    // 如果没有Message, 则设置下次触发超时时间为-1
                    nextPollTimeoutMillis = -1;
               }
        }
    }

next方法主要作用是计算下一个Message触发时间，如果还未到下一个Message的触发时间，则计算到触发剩余时间，如果没有新的Message可以处理，则设置下次触发时间为-1
最终将触发事件作为参数，调用nativePollOnce方法，再接着看下nativePollOnce的用法, 它对应的JNI方法实现在android_os_MessageQueue.cpp中。

static void android_os_MessageQueue_nativePollOnce(JNIEnv* env, jobject obj,
        jlong ptr, jint timeoutMillis) {
    NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
    nativeMessageQueue->pollOnce(env, obj, timeoutMillis);
}

将保存在java层的NativeMessageQueue指针转换成NativeMessageQueue对象， 然后调用该对象的pollOnce方法。

void NativeMessageQueue::pollOnce(JNIEnv* env, jobject pollObj, int timeoutMillis) {
    mPollEnv = env;
    mPollObj = pollObj;
    mLooper->pollOnce(timeoutMillis);
    mPollObj = NULL;
    mPollEnv = NULL;

    if (mExceptionObj) {
        env->Throw(mExceptionObj);
        env->DeleteLocalRef(mExceptionObj);
        mExceptionObj = NULL;
    }
}

NativeMessageQueue的pollOnce方法，最终调用了Native Looper的pollOnce方法

int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
    int result = 0;
    result = pollInner(timeoutMillis);
}

int Looper::pollInner(int timeoutMillis) {
    mPolling = true;

    struct epoll_event eventItems[EPOLL_MAX_EVENTS];
    // 等待 mEpollFd 上的 IO 事件
    int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);

    for (int i = 0; i < eventCount; i++) {
        int fd = eventItems[i].data.fd;
        uint32_t epollEvents = eventItems[i].events;
        if (fd == mWakeEventFd) {
            // 收到mWakeEventFd可读事件
            if (epollEvents & EPOLLIN) {
                awoken();
            } else {
                ALOGW("Ignoring unexpected epoll events 0x%x on wake event fd.", epollEvents);
            }
        } else {
           //  监听的其他文件节点fd时间的处理逻辑
        }
    }
    return result;
}

void Looper::awoken() {
    uint64_t counter;
    TEMP_FAILURE_RETRY(read(mWakeEventFd, &counter, sizeof(uint64_t)));
}

nativePollOnce最终调用到了pollInner方法中，参数timeoutMillis就是next方法中计算的时间，然后将timeoutMillis作为参数调用epoll的epoll_wait方法，等待mEpollFd的IO事件上报。此处timeoutMillis参数为等待超时时间
如果，timeoutMillis > 0, 表示收到IO事件或者等待超时之后返回
如果，timeoutMillis = 0, 表示不等待立刻返回
如果，timeoutMills = -1, 表示没有超时时间，一直阻塞在wait方法上，直到有IO消息上报再返回
当收到IO消息上报之后，调用awoken从mWakeEventFd中读取内容。

小结

至此Looper的初始化过程已经分析完了，做个总结

• Looper.prepare
  为当前线程创建了Looper对象，保存在线程本地内存
  Looper对象中创建了MessageQueue对象，MessageQueue对象中对应了一个NativeMessageQueue对象
  NativeMessageQueue对象中创建了Epoll句柄，用于监听mWakeEventFd文件节点的可读IO事件
• Looper.loop
  不断循环执行，等待符合条件的Message, 按分发机制将消息分发给目标处理者
  loop方法中对于Message队列中的消息执行时间是基于Linux的Epoll机制，每次Epoll触发后分发消息，然后计算下一条Message触发时间，设置为Epoll的下次wait的超时时间

Handler消息发送过程

Looper初始化完成之后，就处于loop循环之中，等待接受消息，消息是如何发送的呢？

创建Handler对象

    public Handler() {
        this(null, false);
    }

   public Handler(Looper looper, Callback callback) {
        this(looper, callback, false);
   }

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

Handler对象创建的时候首先调用myLooper方法从当前线程本地内存中拿到初始化时保存的Looper对象，如果当前线程中没有初始化Looper对象，就会跑出了RuntimeException，这就是线程使用Handler消息机制必须先初始化Looper的原因。
然后从Looper对象中拿出MessageQueue对象保存在mQueue对象中。

创建Message对象

Message创建可以自己new一个Message对象， 也可以使用Handler.obtainMessage()方法，从Message池中获取一个空闲Message，可以重复利用，减少资源消耗。

    public final Message obtainMessage()
    {
        // 调用Message的obtain方法
        return Message.obtain(this);
    }

     public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }

Handler的obtainMessage方法，调用了Message的静态obtain方法，首先判断Message池中是否还有空闲的Message对象，如果有就直接返回一个空闲Message，如果Message池中已经为空，则新创建一个Message返回。

Handler发送消息

sendEmptyMessage
sendEmptyMessageAtTime
sendEmptyMessageDelayed
sendMessage
sendMessageAtFrontOfQueue
sendMessageAtTime
sendMessageDelayed

Hander有很多种发送消息的方法，我们只需要sendMessage方法和sendMessageDelay方法

    public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }

    /**
     * Enqueue a message into the message queue after all pending messages
     * before (current time + delayMillis). You will receive it in
     * {@link #handleMessage}, in the thread attached to this handler.
     *
     * @return Returns true if the message was successfully placed in to the
     *         message queue.  Returns false on failure, usually because the
     *         looper processing the message queue is exiting.  Note that a
     *         result of true does not mean the message will be processed -- if
     *         the looper is quit before the delivery time of the message
     *         occurs then the message will be dropped.
     */
    public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

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

sendMessage方法调用了sendMessageDelayed方法，这个方法第二个参数是消息的延迟时间，sendMessage是无需延迟的，所以这个参数是0，如果需要延迟的话需要设置这个参数，单位为ms
sendMessageDelay方法调用了sendMessageAtTime方法，将延迟时间+当前时间，计算出消息触发的时间点。
最终调用enqueueMessage方法，将Message添加到MessageQueue队列中。

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

将Handler对象本身保存到Message的target变量中，然后调用MessageQueue的enqueueMessage方法。

boolean enqueueMessage(Message msg, long when) {
        如果Message的target变量没有设置，则抛出异常
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }

        synchronized (this) {
            msg.when = when; //消息的触发时间
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
                // 如果比队列最前的Message的触发时间小， 则放在队列最前端，最先触发该消息
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                //遍历MessageQueue队列，按照时间，将Message插入合适的位置
                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; // invariant: p == prev.next
                prev.next = msg;
            }

            // 调用Message的nativeWake方法
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

equeueMessage方法是将Message对象插入到Message队列合适的位置上去，Message队列是按照Message触发时间进行排序的，最先触发的放在队列最前端。将Message插入队列之后，如果消息队列阻塞在Epoll的wait方法上等待消息到来，则调用nativeWake方法唤醒。

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

void NativeMessageQueue::wake() {
    mLooper->wake();
}

通过JNI调用了NativeMessageQueue的wake方法, NativeMessageQueue又调用了Native Looper的wake方法。

void Looper::wake() {
    ssize_t nWrite = TEMP_FAILURE_RETRY(write(mWakeEventFd, &inc, sizeof(uint64_t)));
    if (nWrite != sizeof(uint64_t)) {
        if (errno != EAGAIN) {
            LOG_ALWAYS_FATAL("Could not write wake signal to fd %d: %s",
                    mWakeEventFd, strerror(errno));
        }
    }
}

wake方法其实就是想mWakeEventFd文件节点中写入一个数字，来达到唤醒Epoll wait方法的目的。这样就又回到了Message.next方法中。next方法从nativePollOnce方法中唤醒返回，然后从消息队列拿出第一个消息，查看是否到了触发时间，如果没有到则就算触发剩余时间，然后继续调用nativePollOnce；如果到达触发时间，则将调用Message.target的dispatchMessage方法对消息进行分发。
Message在创建的时候将发送Message的Handler对象设置到了target变量中，下面看下Handler的dispatchMessage方法。

    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            //如果Message的Callback不为null，则调用Message的Callback进行处理
            handleCallback(msg);
        } else {
            //如果Handler的Callback不为空，则调用Handler的Callback进行处理
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
           //否则，调用HandleMessage进行处理
            handleMessage(msg);
        }
    }

首先判断Message的callback是否为空，如果不为空则将Message交给Message的callbak处理；
然后判断如果Handler是否设置了Callback回调，如果设置了则将Message交给 Callback处理；
最后，如果上述两者都没有处理的话就交给handleMessage方法进行处理。

到此Java层的Handler机制就简单分析完成了。