Android 从源码分析Handler消息机制

说起Handler，就不得不提Looper以及Message。我们在使用Handler发送消息时，就是将Message发送到MessageQueue消息队列中，然后通过Looper.loop()方法对MessageQueue消息队列中的消息进行轮询，利用Handler.dispatchMessage(msg)对消息派发，最后复写handleMessage(msg)根据不同的消息进行不同操作。接下来我们开始在源码上进行分析。

Looper

首先对于Looper来说，主要的是Looper.prepare()以及Looper.loop()这两个方法，让我们先看一看Looper.prepare()方法里做了什么。

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()方法了，创建了Looper对象并将其添加到了sThreadLocal对象里，关于sThreadLocal，它是一个ThreadLocal对象，可以在线程中储存变量。同时第二行对sThreadLocat.get()判断是否为空，以抛出异常的方式，避免再次创建Looper对象，这样就保证一个线程中最多只有一个Looper对象和一个MessageQueue消息队列，接下来我们看下Looper的构造函数。

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

在Looper构造函数中，创建了MessageQueue（消息队列）。

所以，在Looper.prepare()函数中，主要是创建了Looper对象并储存到sThreadLocal里，在创建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;

        // Make sure the identity of this thread is that of the local process,
        // and keep track of what that identity token actually is.
        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;
            }

            // This must be in a local variable, in case a UI event sets the logger
            final Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            final long traceTag = me.mTraceTag;
            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }
            try {
                msg.target.dispatchMessage(msg);
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }

            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }

            // Make sure that during the course of dispatching the
            // identity of the thread wasn't corrupted.
            final long newIdent = Binder.clearCallingIdentity();
            if (ident != newIdent) {
                Log.wtf(TAG, "Thread identity changed from 0x"
                        + Long.toHexString(ident) + " to 0x"
                        + Long.toHexString(newIdent) + " while dispatching to "
                        + msg.target.getClass().getName() + " "
                        + msg.callback + " what=" + msg.what);
            }

            msg.recycleUnchecked();
        }
    }

刚开始我们从myLooper()方法中获取到之前储存在sThreadLocal中的Looper对象，然后判断是否为空。从这里可以看出来，在调用Looper.loop()方法前，一定要先调用Looper.prepare()方法，否则会抛出异常。而我们的主线程，在程序启动的时候就已经调用了Looper.prepare()方法。

public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
}

继续往下看，可以知道在loop()方法中我们获取到了MessageQueue这个消息队列，然后通过无限循环对消息进行轮询，如果有消息则取出消息，通过msg.target.dispatchMessage(msg)对消息进行处理，而从Message源码得知msg.target就是Handler这个对象。

所以，从loop()方法中我们获取了储存在sThreadLocal的Looper对象，然后通过它得到MessageQueue消息队列，接下来从MessageQueue中取出消息，如果不为空，则通过msg.target.dispatchMessage(msg)进行处理，最后通过 msg.recycleUnchecked()对消息进行回收。

---

handler

我们先看下handler的构造函数，看看会有什么发现。

public Handler(Callback callback, boolean async) {
        if (FIND_POTENTIAL_LEAKS) {
            final Class<? extends Handler> klass = getClass();
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                    (klass.getModifiers() & Modifier.STATIC) == 0) {
                Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                    klass.getCanonicalName());
            }
        }

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

Handler的构造函数比较多，从这个构造函数中我们可以知道，通过Looper.myLooper()这个方法获取到储存在sThreadLocal中的Looper对象，myLooper()方法上面有源码，就不在说了，我们获取到Looper对象后就可以得到Looper中的MessageQueue消息队列，然后Handler通过MessageQueue与Looper对象产生了联系。

所以在Handler构造函数中，主要做了得到Looper对象，然后通过Looper获取MessageQueue消息队列。

既然得到了MessageQueue，我们是不是应该往里面放消息了？接下来我们看下常用的sendMessage(msg)这个方法。

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

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

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

最后通过enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)方法将我们的要发送的消息放到消息队列中。在这个方法里，我们看到了msg.target = this，是不是很眼熟呢，我们在上面Looper.loop()方法中可以看到，每次取出msg都会交给msg.target.dispatchMessage(msg)去处理。然后我们看下dispatchMessage(msg)里做了什么。

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

在这个方法里，最后调用了handleMessage(msg)这个方法。

public void handleMessage(Message msg) {
}

这里什么都没有，因为这里是我们收到信息后进行处理的地方。我们在使用Handler时，对消息进行处理一定要复写handleMessage(Message msg)这个方法，根据msg.what进行不同操作。

---

至此，整个流程已经分析完了，最后我们来做个总结。

• Looper

  在Looper中，我们主要进行了两个操作

  Looper.prepare():

  在prepare()中，我们创建了Looper对象，并且在Looper构造函数中创建了MessageQueue这个消息队列，同时将Looper对象储存到sThreadLocal中。值得注意的是，当Looper与线程绑定时，只能存在一个Looper对象，一个MessageQueue队列。

  Looper.loop():

  在loop()中，首先获取到储存在sThreadLocal中的Looper对象，然后通过Looper对象得到MessageQueue消息队列。接着对消息队列进行无限循环取出每一个Message对象，如果不为空则利用msg.target.dispatchMessage(msg)对消息进行处理。

• Handler

  在Handler中，首先当我们初始化Handler时，通过myLooper()这个方法获取到Looper对象，从而得到MessageQueue消息队列。然后开始进行发送消息以及处理消息这两个过程。

  发送消息：

  我们从sendMessage(msg)一步一步观察得知，最后通过enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)方法将Message放入到MessageQueue中。这是发送消息的过程。

  处理消息：

  我们知道在Looper.loop()开始对MessageQueue消息队列进行无限循环取出消息，然后通过msg.target.dispatchMessage(msg)对消息进行处理，最后再复写handleMessage(msg)对获取到的消息进行不同操作。这是处理消息的过程。

参考博文:
http://blog.csdn.net/lmj623565791/article/details/38377229/