Handler机制

Handler机制，主要牵涉到的类有如下四个，它们分工明确，但又相互作用

Message：消息
Hanlder：消息的发起者
Looper：消息的遍历者
MessageQueue：消息队列
下面我们从Handler的套路，来分析他们的作用

而Handler 的创建必须要有 Looper 对象，我们来看看Looper 的流程：

Looper.prepare()

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

    private static void prepare(boolean quitAllowed) {
        // 规定了一个线程只有一个Looper，也就是一个线程只能调用一次Looper.prepare()
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        // 如果当前线程没有Looper，那么就创建一个，存到sThreadLocal中
        sThreadLocal.set(new Looper(quitAllowed));
    }

从上面的代码可以看出，一个线程最多只有一个Looper对象。当没有Looper对象时，去创建一个Looper，并存放到sThreadLocal中，sThreadLocal是一个static的ThreadLocal对象，关于它的详细使用，以后有机会再介绍，这里只要知道，它存储了Looper对象的副本，并且可以通过它取得当前线程在之前存储的Looper的副本。

Looper构造函数

    private Looper(boolean quitAllowed) {
        // 创建了MessageQueue，并供Looper持有
        mQueue = new MessageQueue(quitAllowed);
        // 让Looper持有当前线程对象
        mThread = Thread.currentThread();
    }

这里主要就是创建了消息队列MessageQueue，并让它供Looper持有，因为一个线程最大只有一个Looper对象，所以一个线程最多也只有一个消息队列。然后再把当前线程赋值给mThread。

MessageQueue的构造方法没有什么可讲的，它就是一个消息队列，用于存放Message。

所以Looper.prepare()的作用主要有以下三点

1、创建Looper对象
2、创建MessageQueue对象，并让Looper对象持有
3、让Looper对象持有当前线程

Handler创建

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

    public Handler(Callback callback, boolean async) {
      // 不相关代码
       ......
        //得到当前线程的Looper，其实就是调用的sThreadLocal.get
        mLooper = Looper.myLooper();
        // 如果当前线程没有Looper就报运行时异常
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        // 把得到的Looper的MessagQueue让Handler持有
        mQueue = mLooper.mQueue;
        // 初始化Handler的Callback，其实就是最开始图中的回调方法的2
        mCallback = callback;
        mAsynchronous = async;
    }

首先，调用了Looper.myLooper，其实就是调用sThreadLocal.get方法，会得到当前线程调用sThreadLocal.set保存的Looper对象，让Handler持有它。接下来就会判断得到的Looper对象是否为空，如果为空，就会报
"Can’t create handler inside thread that has not called Looper.prepare()，这不就是我们之前在没有调用Looper.prepare就在子线程中创建Handler时报的错误嘛。的确，当我们没有调用Looper.prepare()，则当前线程中是没有Looper对象的。

然后，让Handler持有得到的Looper对象的MessageQueue和设置处理回调的Callback对象（最开始图中的回调方法2）。

到这里，默认的Handler的创建过程就结束了，主要有以下几点

1、创建Handler对象
2、得到当前线程的Looper对象，并判断是否为空
3、让创建的Handler对象持有Looper、MessageQueu、Callback的引用

Looper.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.");
        }
        // 得到当前线程的MessageQueue对象
        final MessageQueue queue = me.mQueue;
        
        // 无关代码
        ......
        
        // 死循环
        for (;;) {
            // 不断从当前线程的MessageQueue中取出Message，当MessageQueue没有元素时，方法阻塞
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
            // Message.target是Handler，其实就是发送消息的Handler，这里就是调用它的dispatchMessage方法
            msg.target.dispatchMessage(msg);
            // 回收Message
            msg.recycleUnchecked();
        }
    }

首先还是判断了当前线程是否有Looper，然后得到当前线程的MessageQueue。接下来，就是最关键的代码了，写了一个死循环，不断调用MessageQueue的next方法取出MessageQueue中的Message，注意，当MessageQueue中没有消息时，next方法会阻塞，导致当前线程挂起，后面会讲到。

拿到Message以后，会调用它的target的dispatchMessage方法，这个target其实就是发送消息时用到的Handler。所以就是调用Handler的dispatchMessage方法，代码如下：

 public void dispatchMessage(Message msg) {
        // 如果msg.callback不是null，则调用handleCallback
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            // 如果 mCallback不为空，则调用mCallback.handleMessage方法
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            // 调用Handler自身的handleMessage，这就是我们常常重写的那个方法
            handleMessage(msg);
        }
    }

首先，判断msg.callback是不是空，其实msg.callback是一个Runnable对象，是Handler.post方式传递进来的参数，后面会讲到。而hanldeCallback就是调用的Runnable的run方法。

然后，判断mCallback是否为空，这是一个Handler.Callback的接口类型，之前说了Handler有多个构造方法，可以提供设置Callback，如果这里不为空，则调用它的hanldeMessage方法，注意，这个方法有返回值，如果返回了true，表示已经处理 ，不再调用Handler的handleMessage方法；如果mCallback为空，或者不为空但是它的handleMessage返回了false，则会继续调用Handler的handleMessage方法，该方法就是我们经常重写的那个方法。

发送消息

使用Handler发送消息主要有两种，一种是sendXXXMessage方式，还有一个postXXX方式，不过两种方式最后都会调用到sendMessageDelayed方法，所以我们就以最简单的sendMessage方法来分析。

    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其实就是创建时的MessageQueue，默认情况是当前线程的Looper对象的MessageQueue
        // 也可以指定
        MessageQueue queue = mQueue;
        if (queue == null) {
            RuntimeException e = new RuntimeException(
                    this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
            return false;
        }
        // 调用enqueueMessage，把消息加入到MessageQueue中
        return enqueueMessage(queue, msg, uptimeMillis);
    }

    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        // 把当前Handler对象，也就是发起消息的handler作为Message的target属性
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        // 调用MessageQueue中的enqueueMessage方法
        return queue.enqueueMessage(msg, uptimeMillis);
    }

首先，把当前Handler作为Message的target属性，方便Looper从MessageQueue中取出Message时进行消息处理。然后调用了MessageQueue的enqueueMessage方法，把handler发送的消息加入到MessageQueue，供Looper去取出来处理。我们记下来看看MessageQueue的enqueueMessage方法：

   boolean enqueueMessage(Message msg, long when) {
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }
        // 一个Message，只能发送一次
        if (msg.isInUse()) {
            throw new IllegalStateException(msg + " This message is already in use.");
        }

        synchronized (this) {
            if (mQuitting) {
                IllegalStateException e = new IllegalStateException(
                        msg.target + " sending message to a Handler on a dead thread");
                Log.w("MessageQueue", e.getMessage(), e);
                msg.recycle();
                return false;
            }
            // 标记Message已经使用了
            msg.markInUse();
            msg.when = when;
            // 得到当前消息队列的头部
            Message p = mMessages;
            boolean needWake;
            // 我们这里when为0，表示立即处理的消息
            if (p == null || when == 0 || when < p.when) {
                // 把消息插入到消息队列的头部
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                // 根据需要把消息插入到消息队列的合适位置，通常是调用xxxDelay方法，延时发送消息
                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;
            }

            // 如果队列阻塞了，则唤醒
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

首先，判断了Message是否已经使用过了，如果使用过，则直接抛出异常，这是可以理解的，如果MessageQueue中已经存在一个Message，但是还没有得到处理，这时候如果再发送一次该Message，可能会导致处理前一个Message时，出现问题。

然后，会判断when，它是表示延迟的时间，我们这里没有延时，所以为0，满足if条件。把消息插入到消息队列的头部。如果when不为0，则需要把消息加入到消息队列的合适位置。

最后会去判断当前线程是否已经阻塞了，如果阻塞了，则需要调用本地方法去唤醒它。

以上是sendMessage的全部过程，其实就是把Message加入到MessageQueue的合适位置。那我们来简单看看post系列方法：

   public final boolean post(Runnable r)
   {
      return  sendMessageDelayed(getPostMessage(r), 0);
   }

   private static Message getPostMessage(Runnable r) {
       // 构造一个Message，并让其callback执行传来的Runnable
       Message m = Message.obtain();
       m.callback = r;
       return m;
   }

post 方法 其实就是发送了一个空的 message， Handler 接受到该消息后执行的操作是post方法中传进来的 参数 Runnable的 run方法。

我们再来总结下Handler消息机制主要的四个类的功能

1、Message:信息的携带者，持有了Handler，存在MessageQueue中，一个线程可以有多个
2、Hanlder:消息的发起者，发送Message以及消息处理的回调实现，一个线程可以有多个Handler对象
3、Looper:消息的遍历者，从MessageQueue中循环取出Message进行处理，一个线程最多只有一个
4、MessageQueue:消息队列，存放了Handler发送的消息，供Looper循环取消息，一个线程最多只有一个
再来看看开始的结构图，是不是一目了然了：

手动转载自: Handler处理机制详解.