【内核研究】循环接收者_Looper

Looper的作用有两点：

• 为调用静态方法prepare()的线程创建一个消息队列MessageQueue。
• 提供静态方法loop()，使调用该方法的线程进入无限循环，并从消息队列中读取消息。

Looper的静态方法prepare()中，会给线程局部存储添加一个新的Looper对象，而Looper的构造函数中，会创建一个MessageQueue消息队列，代码如下：

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

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

对程序员来讲，当需要把一个线程变为异步消息处理线程的时候，应该在Thread类的run()函数中先调用Looper.prapare()为该线程创建一个MessageQueue对象，然后再调用Looper.loop()函数，使当前线程进入消息处理循环。使用范例，代码如下：

/**
  * Class used to run a message loop for a thread.  Threads by default do
  * not have a message loop associated with them; to create one, call
  * {@link #prepare} in the thread that is to run the loop, and then
  * {@link #loop} to have it process messages until the loop is stopped.
  * 
  * <p>Most interaction with a message loop is through the
  * {@link Handler} class.
  * 
  * <p>This is a typical example of the implementation of a Looper thread,
  * using the separation of {@link #prepare} and {@link #loop} to create an
  * initial Handler to communicate with the Looper.
  * 
  * <pre>
  *  class LooperThread extends Thread {
  *      public Handler mHandler;
  *      
  *      public void run() {
  *          Looper.prepare();
  *          
  *          mHandler = new Handler() {
  *              public void handleMessage(Message msg) {
  *                  // process incoming messages here
  *              }
  *          };
  *          
  *          Looper.loop();
  *      }
  *  }</pre>
  */

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

该段代码的执行流程如下：

1. 调用myLooper()函数返回当前线程的Looper对象，该函数内部仅仅通过调用sThreadLocal.get()方法返回当前线程id对应的Looper对象。

    /**
     * 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() {
        return (Looper)sThreadLocal.get();
    }

2. 进入while(true)无限循环

1) 调用MessageQueue对象的next()函数取出队列中的消息。注意，如果当前队列为空，则当前线程会被挂起，也就是说，next()函数内部会暂停当前线程。

2) 回调msg.target.dispatchMessage()函数，完成对消息的处理，也就是说，消息的具体处理实际上是由程序指定的。msg变量的类型是Message，msg.target的类型是Handler。

3) 每处理完该消息后，需要调用msg.recycle()回收该Message对象占用的系统资源。因为Message内部使用了一个数据池保存Message对象，从而避免不停地创建和删除Message对象。因此，每次处理完该消息后，需要将该Message对象设置为空闲状态，以便使该Message对象可以被重用。