【源码解读】Handler消息机制流程分析

之前看《艺术探索》大致了解了Android消息机制的原理，也总结了笔记，但总感觉理解的不够彻底，之后把源码和之前的笔记又看了一遍，算是基本通了，将基本逻辑记录在此，重在分析流程，不分析具体细节原理。

这里以主线程为例，Handler消息机制的完整过程如下：

1.线程创建Looper, 同时初始化MessageQuene和Thread对象，开启循环

在ActivityThread的main方法中，会首先创建主线程的Handler，因此我们在主线程中是可以创建Handler对象而不需要考虑Looper问题的。

 public static void main(String[] args) {
    //代码省略...
    Looper.prepareMainLooper();
    Looper.loop();
 }

最终通过prepare方法创建Looper对象并使用ThreadLocal进行存储，源码如下：

public static void prepareMainLooper() {
    prepare(false);
    synchronized (Looper.class) {
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        sMainLooper = myLooper();
    }
}

//最终调用该方法创建Looer对象,因为是主线程所以这里的参数为false
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的构造函数中会同时创建其MessageQuene和Thread对象.这样就创建好了我们需要的Looper对象以及MessageQueue和Thread对象，并通过Looper.loop()方法开启无限循环

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

2.创建Handler对象

这里最常使用的方式就是新建一个Handler对象并传递一个CallBack对象，当然还有其他的构造方法，这里不作赘述

    private  Handler handler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            switch (msg.what){
                case 1:
                    String obj = (String) msg.obj;
                    Log.i(TAG, obj);
                    break;
            }
            return true;
        }
    });

3.sendMessage或者post一个Runnable对象

使用创建好的handler对象传递消息，无论是sendMessage还是post一个Runnable对象，最终会调用到
sendMessageAtTime,之后会调用MessageQuene对象的enqueueMessage()方法将消息加入到队列中

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

    //设置msg.target为当前Handler对象，并将消息存储进消息队列
  private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

4.在loop方法中，调用handler的dispatcher进行分发.

在prepare好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 (;;) {
            /**
            * 调用MessageQuene的next方法获取消息对象,如果没有消息则终止循环
            */
            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
            Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            /**
            * msg.target就是在enqueueMessage方法中设置好的Handler对象，
            * 调用dispatchMessage进行消息分发
            */
            msg.target.dispatchMessage(msg);

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

loop内部也是无限循环，去调用MessageQuene的next方法，如果有消息则拿到消息对象并通过Handler对象进行分发进行分发

5.dispatchMessage对消息进行分发，根据传递的消息选择不同的调用，具体如下

   public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
        //检查Message的callback是否为空，不为空则调用handleCallback
        //当我们使用post提交一个Runnable对象的时候回调用该方法，最终执行我们
        //的Runnable对象的run方法中的内容
            handleCallback(msg);

        } else {
            if (mCallback != null) {
                //当使用sendMessage发送信息并创建了CallBack对象时调用
                //这就是我们最常见的使用方法，最终会调用到我们重写的handleMessaeg方法
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            //调用Handler自己的handleMessage，方面里面为空，啥都不干
            handleMessage(msg);
        }
    }

简单来说,在子线程通过主线程的Handler对象发送数据时，最终会调用到Handler的handleMessage方法进行处理，因为Handler处于主线程，那么此时操作就从子线程切换到了主线程，从而线程间的通信。

OK，以上就是整个Handler消息机制的创建处理流程。