Handler、Looper、Message、MessageQune之间的原理

说到sendMessage，开发中用的比较多，是Handler的方法，而Handler的机制，在整个Android系统中的应用非常广泛，当然，也是面试中经常问到的知识点，过一过源码，在此梳理下，

首先，一般使用Handler代码是这样的，如下：

   Handler handler = new Handler(){public void handleMessage(android.os.Message msg) {Toast.makeText(MainActivity.this, (String)msg.obj, 0).show();}};//发送消息handler.sendMessage(msg);

那么，整个机制的具体流程是怎样的呢？先看下Handler

Handler.java

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

    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()");}mQueue = mLooper.mQueue;mCallback = callback;mAsynchronous = async;}

我们经常使用Handler的默认构造函数，创建Handler对象，默认构造函数内，会调用带参数的构造函数，显然 ，这里的callbcak，mCallback为null，asyn，mAsynchronous

为false，Looper的myLooper方法执行后，mLooper初始化完成，这里，可以从mLooper中获取对应的一个mQueue，也就是MessageQune

下面，就来了解下Looper的创建

1.Looper的创建：

Looper.java

    private static Looper sMainLooper;public static void prepareMainLooper() {prepare(false);synchronized (Looper.class) {if (sMainLooper != null) {throw new IllegalStateException("The main Looper has already been prepared.");}sMainLooper = myLooper();}}public static void prepare() {prepare(true);}public static Looper myLooper() { return sThreadLocal.get(); }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));}private Looper(boolean quitAllowed) {mQueue = new MessageQueue(quitAllowed);mThread = Thread.currentThread();｝

看完这段，大致了解到，上面Handler的构造方法中，调用Looper的myLooper()方法来获取Looper对象，myLooper()内部关系到sThreadLocal变量，通过get()方法得到Looper。同

时，我们发现在prepare(quitAllowed)的方法内部，sThreadLocal通过set设置了新的Looper实例来保存，这样，我们知道了sThreadLocal实际上是用来存储Looper对象的，并且是一

个线程只能对应一个Looper，如下：

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

注释的含义大致是，只有我们调用了prepare()方法，sThreadLocal才会返回Looper对象，否则为null。那么，我们可以这样理解，prepare()的调用，能够创建Looper对象，同时创

建了mQueue（MessageQune对象），而其内部调用prepare(quitAllowed)，prepareMainLooper也调用了prepare(quitAllowed)，而且，prepare()与prepareMainLooper()全部是public

static 修饰的，这说明，它们是专门供外部来调用从而获取Looper对象的。事实果真是如此吗？先来看下，省略部分无关代码，如下：

ActivityThread.java

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

的确，在ActivityThread中main方法执行了prepareMainLooper()，loop()也被执行，而main方法是系统调用，同时，也就是说，系统预先帮我们创建好了Looper对象，并且开

启轮询。至于prepare()，也有用到，我们可以在子线程中使用Looper.prepare()，Looper.loop()，创建自己的Looper。记住，一定要先prepare，要知道，巧妇难成无米之炊，

体会下吧。到此，Looper的创建过程以及基本了解。

接着来看loop()是内部是如何的

2.Looper的轮询：

    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;//...for (;;) {Message msg = queue.next(); // might blockif (msg == null) {return;}//...msg.target.dispatchMessage(msg);//...msg.recycleUnchecked();}}

我们注意到loop()的内部，先是获取到Looper对象，通过Looper得到对应的MessageQune，也就是mQueue。

接下来是无限的循环，不断的从mQueue消息队列中取消息，如果没有取到，消息为null，不再向下执行，继续循环取，一旦取到Message，就会通过Message的target，派发

消息，之后对已派发的Message进行回收

target实际上就是Handler，后面还会看到，在此说明下

关于消息的回收，是对消息的相关参数进行出厂设置，也就是，将参数设置为null或者0，但是，消息对象还在，没有销毁，可以重复利用，这点也可以从Message的obtain()方

法验证

好了，经过上面两个步骤，我们的Looper创建好了，也开始工作了，尽管是系统帮忙的，但是我们可以发消息了，继续看Message的发送过程

3.Handler发送消息到MessageQune：

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

以上的过程是在Handler中完成的，消息发出后可以根据返回值，判断是否发送成功，继续看

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

这里是上面提到的target，是this，就是当前Handler对象，也就是说，Handler发送消息时，绑定了自己，为什么绑定自己呢？这跟谁污染谁治理的原则是一样的，当然，没那

么严重，是谁发送消息，就是谁处理消息，始终唯一

接下俩，就是将Messager进行编队，入列的过程

4.MessageQueue对Message入列：

MessageQueue.java

    boolean enqueueMessage(Message msg, long when) {if (msg.target == null) {throw new IllegalArgumentException("Message must have a target.");}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(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) {break;}if (needWake && p.isAsynchronous()) {needWake = false;}}msg.next = p; // invariant: p == prev.nextprev.next = msg;}// We can assume mPtr != 0 because mQuitting is false.if (needWake) {nativeWake(mPtr);}}return true;}

可以看到，内部有个无限循环，为什么要无限循环呢？因为MessageQune 是很被动的，它不知道什么时候会有消息要加入，才会不断循环，只要有Message 消息进来，就会将

Message进行编队，没有就跳出循环。接下来，终于等到派发Message消息，如下：Message的消息分发到Handler

msg.target.dispatchMessage(msg);

这句代码是在loop()中执行的，为了说明，最终Message是派发给当初负责发送它的Handler对象的，有点物归原主的含义，可以体会下

下面，看Handler如何回调handMessage的

5.Handler回调方法处理消息：

Handler.java

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

在Handler对象创建时，mCallBack为null，callBack也为null，消息派发后，就调用handMessage方法，

文章开头，重写的handMessage方法

    Handler handler = new Handler(){public void handleMessage(android.os.Message msg) {Toast.makeText(MainActivity.this, (String)msg.obj, 0).show();}};

经过上面的几个过程，handMessage方法被调用，吐司最终展示在UI界面上

好啦，以上就是Handler、Looper、MessageQueue之间的关系描述，收拾下，吃饭了...