Looper、Handler的关系（二）

       上篇文章只是简单的说明了一下Android中的消息处理机制原理是什么，接下来将详细探讨其中的几个关键类。首先是Looper类。

Looper、Handler的关系（一）

        首先看看Looper是如何使用的。典型的使用looper的例子是这样的：

class LooperThread extends Thread {      public Handler mHandler;      public void run() {          Looper.prepare();          mHandler = new Handler(Looper.myLooper()) {//将Handler绑定到LooperThread的Looper中。              public void handleMessage(Message msg) {                  // process incoming messages here              }          };          Looper.loop();      }  }//在程序中某个地方直接调用：new LooperThread().start();

       在上面的代码中，Looper类的两个方法被调用了，Looper.prepare()和Looper.loop();

一、prepare()

       以下是Looper类prepare()方法的源码：

  // sThreadLocal.get() will return null unless you've called prepare().    private static final ThreadLocal sThreadLocal = new ThreadLocal();         /** Initialize the current thread as a looper.      * This gives you a chance to create handlers that then reference      * this looper, before actually starting the loop. Be sure to call      * {@link #loop()} after calling this method, and end it by calling      * {@link #quit()}.      */    public static final void prepare() {        if (sThreadLocal.get() != null) {            throw new RuntimeException("Only one Looper may be created per thread");        }        sThreadLocal.set(new Looper());    }

       ThreadLocal是Java中的线程局部变量类。该类有两个关键方法：set()和get()，分别是设置调用线程的局部变量和获取调用线程的局部变量。这两个方法的结果都是与调用这个函数的线程有关。

       因此，prepare()方法会在调用的线程的局部变量中设置一个Looper对象。这个线程也就是上面的LooperThread线程（由于LooerThread线程中调用了prepare()方法）。

       再来看看Looper的构造函数：

    final MessageQueue mQueue;    volatile boolean mRun;    Thread mThread;      private Looper() {        mQueue = new MessageQueue();        mRun = true;        mThread = Thread.currentThread();    }

       构造函数只是创建了消息队列，并初始化了当前线程的Thread对象。

       通过上面的分析，可以得到：在调用prepare()的线程中，创建了一个Looper对象，这个Looper对象被保存在了这个线程的局部变量中（ThreadLocal），同时，在Looper中，创建了一个消息队列。也就是说，prepare()方法，利用了线程的局部变量（ThreadLocal）机制，将线程与Looper关联上了。

二、loop()

       以下是部分源码：

 /**     *  Run the message queue in this thread. Be sure to call     * {@link #quit()} to end the loop.     */    public static final void loop() {        Looper me = myLooper();        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();                while (true) {            Message msg = queue.next(); // might block            //if (!me.mRun) {            //    break;            //}            if (msg != null) {                if (msg.target == null) {                    // No target is a magic identifier for the quit message.                    return;                }                if (me.mLogging!= null) me.mLogging.println(                        ">>>>> Dispatching to " + msg.target + " "                        + msg.callback + ": " + msg.what                        );                msg.target.dispatchMessage(msg);                if (me.mLogging!= null) me.mLogging.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("Looper", "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.recycle();            }        }    }    /**     * Return the Looper object associated with the current thread.  Returns     * null if the calling thread is not associated with a Looper.     */    public static final Looper myLooper() {//返回保存在线程局部变量中的Looper对象。        return (Looper)sThreadLocal.get();    }

      在loop()方法中，

msg.target.dispatchMessage(msg);

     这行代码可能不太理解。msg.target实际就是Handler，在Message的源码中，target就是消息的Handler，回调handler的dispatchMessage方法。

     通过对上面Looper源码的分析，可以概括Looper的作用：

1、封装消息队列。在创建Looper对象时就创建了，在循环中，从队列中获取消息等处理。

2、Looper的prepare方法，将此Looper与调用prepare方法的线程关联起来了。这个线程，也就是最终的处理线程，将二者绑在了一起。

3、loop方法，则是处理消息队列中的消息。

接下来，说明一下Looper、Message和Handler三者的关系：

*Looper中有一个Message队列，里面存储的是待处理的Message；

*Message中有一个Handler，这个Handler是用来处理Message消息的。

 下一节将讨论Handler类。