Android消息机制

Looper

1 . Looper是一个线程的消息循环器，默认情况下，线程中是没有 Looper的。Looper的经典用法如下：

class LooperThread extends Thread {        public Handler mHandler;        public void run() {           Looper.prepare();            mHandler = new Handler() {                public void handleMessage(Message msg) {                    // todo                }            };            Looper.loop();        }    }

2 . Looper.prepre():
prepre()会调用prepre(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));    }

sThreadLocal是一个静态成员变量，用来存储本地线程一些变量的，这说明在同一个线程中，prepre只能被调用一次，因此一个线程中最多只能有一个 Looper 对象。同时 Looper 的构造方法是私有的，在创建一个 Looper实例时会同时创建一个与之相应的消息队列MessageQueue；

3 . Looper.loop():
loop会对消息队列（message queue）进行无限轮询，如果消息队列中有消息则进行消息的分发，分发结束后又开始下一次的轮询。可以通过调用quit()结束轮询。

    public static void loop() {    //从刚刚那个sThreadLocal中取出Looper对象        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;        //就是用来保证当前线程是否被篡改        Binder.clearCallingIdentity();        final long ident = Binder.clearCallingIdentity();        //开始消息的轮询        for (;;) {        //如果没有消息了，会Block住，queue.mBlocked=ture            Message msg = queue.next();             if (msg == null) {                return;            }         //****************省略部分代码****************            try {            //消息分发                msg.target.dispatchMessage(msg);            } finally {         //****************省略部分代码****************            }            //如果分发消息过程中线程被篡改则打印些提示 log            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();        }    }

在消息的分发过程中，调用的是msg.target.dispatchMessage(msg)，这里的 target 对象其实就是发出iith消息的那个 Handler 对象，下面来看看Handler.sendEmptyMessage(int what)方法

Handler

1 . Handler.sendEmptyMessage(int what)
下面来看通过 Handler 发送一个消息出去的过程，所有的消息发送最后都会调用sendMessageAtTime(Message msg, long uptimeMillis)：

  public boolean sendMessageAtTime(Message msg, long uptimeMillis) {  //mQueue 是 Handler 实例化时从 Looper 中获取的，所以与 Looper 中的是同一个。        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方法中会设置msg.target = this(当前 handler)，并且最终会调queue.enqueueMessage（queue, msg）        return enqueueMessage(queue, msg, uptimeMillis);    }

2 . MessageQueue.enqueueMessage（queue, msg）

    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) {           //****************省略部分代码****************            msg.markInUse();            msg.when = when;            Message p = mMessages;            boolean needWake;             //如是 p为空，表明消息队列中没有消息了，那么msg将是第一个消息            if (p == null || when == 0 || when < p.when) {                msg.next = p;                mMessages = msg;                needWake = mBlocked;            } else {                //对Handler发出于默认的消息,msg.isAsynchronous()=false                //mBlocked代表着消息队列是否被Block住了，参考 Looper.loop（） 以及MessageQueue.next()                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;                prev.next = msg;            }            if (needWake) {            //唤醒Looper                nativeWake(mPtr);            }        }        return true;    }

3 . 消息的分发 dispatchMessage(Message msg)

  public void dispatchMessage(Message msg) {  //msg.callback其实是创建Messag对象时传入的Runnable对象。如果传入了Runnable，则处理消息时由Runnable对象来处理，即调用 run 方法        if (msg.callback != null) {            handleCallback(msg);        } else {        //同理，如果 mCallback不为空，则由mCallback来处理,CallBack是 Handler 中的一个接口，构建 Handler 时可传入一个全局实现            if (mCallback != null) {                if (mCallback.handleMessage(msg)) {                    return;                }            }            //这就是我们平时重写的handleMessage方法            handleMessage(msg);        }    }

总结

Looper,Handler,MessageQueue 三者的相互配合，构成 Andoid 系统的消息机制，其中MessageQueue作为消息的容器，而 Looper负责对 MessQueue 进行轮询，当没有消息需要处理时，就会处于 Block 状态，而 Handler 负责将消息发送到MessageQueue中，并同时负责消息的分发或者处理，处理时首先交给 Message的 callback 对象，否则交给 Handler 的 mCallback 处理，如果都没处理最后才会交给 handleMessage 方法进行处理。对于一个线程来说，最多只能有一个 Looper 以及 MessageQueue，而 handler 可以有多个；