Handler,Looper,MessageQueue(Message)

1.Looper

先介绍Looper吧，顾名思义就是环、回路，意味着循环。Looper是对消息循环的封装，可理解为一个消息队列，可以添加和循环获取其中内容。它与一个具体线程相关，从SDK中Looper的注释有一个最简单的例子，表明它和线程的关系：

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

当使用

new LooperThread().start()

　　

时执行run()方法，先调用Looper.prepare()，该方法做什么东西：

    public static final void prepare() {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper());
    }

sThreadLocal是一个Looper的静态全局变量，一开始就初始化了

private static final ThreadLocal sThreadLocal = new ThreadLocal();

然后调用sThreadLocal.set(new Looper())：

    public void set(T value) {
        Thread currentThread = Thread.currentThread();//获取当前线程
        Values values = values(currentThread);
        if (values == null) {
            values = initializeValues(currentThread);
        }
        values.put(this, value);//简单理解为把传进来的Looper对象value保存起来
    }

set()方法的作用主要是把传进来的Looper和当前的线程建立一个关联关系

然后Looper.prepare()的过程完成，接下来调用Looper.loop()，接下来就是new一个Handler对象，这里先不介绍，后面会说，最后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();//myLooper（）作用就是把刚好set(T value)中保存的Looper取出来
        MessageQueue queue = me.mQueue;//每一个Looper都有自己的MessageQueue
        while (true) {//无限循环执行
            Message msg = queue.next(); // might block取出一条Message
            //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);//msg.target是一个Handler对象，然后分发msg
                if (me.mLogging!= null) me.mLogging.println(
                        "<<<<< Finished to    " + msg.target + " "
                        + msg.callback);
                msg.recycle();
            }
        }
    }

由于该无限循环牵涉到MessageQueue(Message),所以接下来简单介绍一下MessageQueue和Message。 

2.MessageQueue和Message

其实MessageQueue很简单，从名字就知道它是一个消息队列，只是一个“数据存储结构”而已，保存的Message对象。而该存储结构可以理解为一个链表，每一个Message对象中包含一个next变量用于引用下一个Message对象，理解为一个指针。每一个Looper对象都有自己的MessageQueue，MessageQueue是Looper的一个全局变量，在构造函数的时候就赋值了：

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

 

MessageQueue的方法基本就是获取消息队列中的Message对象，这里不做详细解释。

介绍一下Message,它有几个重要的全局变量:

    /**
     * User-defined message code so that the recipient can identify 
     * what this message is about. Each {@link Handler} has its own name-space
     * for message codes, so you do not need to worry about yours conflicting
     * with other handlers.
     */
    public int what;//用户定义的标识，可以理解为id

    // Use these fields instead of using the class's Bundle if you can. 
    /** arg1 and arg2 are lower-cost alternatives to using {@link #setData(Bundle) setData()}
    if you only need to store a few integer values. */
    public int arg1; //如果希望带上简单的int数据可以用这个参数，而不需要用Bundle

    /** arg1 and arg2 are lower-cost alternatives to using {@link #setData(Bundle) setData()}
    if you only need to store a few integer values.*/ 
    public int arg2;

    /** An arbitrary object to send to the recipient.  This must be null when
     * sending messages across processes. */
    public Object obj;//发送给接收者的任意对象，当夸进程发送时必须为空

    /** Optional Messenger where replies to this message can be sent.
     */
    public Messenger replyTo;
    
    /*package*/ long when;//主要用户保存时间
    
    /*package*/ Bundle data;//数据
    
    /*package*/ Handler target;    //将要处理该消息的Handler对象 
    
    /*package*/ Runnable callback; //回调函数  
    
    // sometimes we store linked lists of these things
    /*package*/ Message next;//指向MessageQueue中的下一个Message，这样MessageQueue就构成了一个链式结构

 

从上面看，貌似 Handler,Looper,MessageQueue(Message)三者还没有什么联系，特别是Handler，那接下来就介绍Handler

3.Handler

刚才省略了说明的一步：

  *          mHandler = new Handler() {
  *              public void handleMessage(Message msg) {
  *                  // process incoming messages here
  *              }
  *          };

这里就是一个构造函数，那么这个构造函数究竟做了什么：

    /**
     * Default constructor associates this handler with the queue for the
     * current thread.
     *
     * If there isn't one, this handler won't be able to receive messages.
     */
    public Handler() {
        if (FIND_POTENTIAL_LEAKS) {
            final Class<? extends Handler> klass = getClass();
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                    (klass.getModifiers() & Modifier.STATIC) == 0) {
                Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                    klass.getCanonicalName());
            }
        }

        mLooper = Looper.myLooper();//这里解释确定刚才Looper.prepare()时set的Looper对象（哈哈，有联系了吧）
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;//把自己的全局的MessageQueue变量mQueue指向了本线程中Looper对象的MessageQueue
        mCallback = null;
    }

然后我们执行一个简单的发送消息函数，例如：

    /**
     * Sends a Message containing only the what value.
     *  
     * @return Returns true if the message was successfully placed in to the 
     *         message queue.  Returns false on failure, usually because the
     *         looper processing the message queue is exiting.
     */
    public final boolean sendEmptyMessage(int what)
    {
        return sendEmptyMessageDelayed(what, 0);
    }

一直往下看，会执行：

    /**
     * Enqueue a message into the message queue after all pending messages
     * before the absolute time (in milliseconds) <var>uptimeMillis</var>.
     * <b>The time-base is {@link android.os.SystemClock#uptimeMillis}.</b>
     * You will receive it in {@link #handleMessage}, in the thread attached
     * to this handler.
     * 
     * @param uptimeMillis The absolute time at which the message should be
     *         delivered, using the
     *         {@link android.os.SystemClock#uptimeMillis} time-base.
     *         
     * @return Returns true if the message was successfully placed in to the 
     *         message queue.  Returns false on failure, usually because the
     *         looper processing the message queue is exiting.  Note that a
     *         result of true does not mean the message will be processed -- if
     *         the looper is quit before the delivery time of the message
     *         occurs then the message will be dropped.
     */
    public boolean sendMessageAtTime(Message msg, long uptimeMillis)
    {
        boolean sent = false;
        MessageQueue queue = mQueue;//又取得了Looper中的MessageQueue
        if (queue != null) {
            msg.target = this;//看到了没！！！！！！！！Message对象的target变量为this，也就是，Message对象持有了该Handler
            sent = queue.enqueueMessage(msg, uptimeMillis);
        }
        else {
            RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
        }
        return sent;
    }

代码中可见，当发送一个消息时，先会取得Looper中的MessageQueue，使的Handler自己的MessageQueue和Looper的MessageQueue引用的是同一个对象，而消息本身又持有了当前的Handler对象，然后这个消息就会进入到Looper的MessageQueue中了（通过MessageQueue.enqueueMessage()实现）

回头看Looper.loop()的一段代码：

msg.target.dispatchMessage(msg);

看到没有，最终把Message分发出去的其实就是Message自己持有的那个Handler对象target

    /**
     * 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自己的回调对象处理消息。

回顾上面，Handler,Looper,MessageQueue(Message)三种的关系就清晰了：线程关联一个对象Looper(Looper.prepare()实现)，Looper一直循环在取它自己的MessageQueue中的消息Message（通过调用Looper.loop()可见），如果有消息的话，就会把消息分发出去，而该消息的分发就是通过Handler实现分发的，而Handler发送消息时，则是往Looper.MessageQueue中添加消息，等待Looper.loop()不断循环时把自己分发出去。三者关系就是这么简单，无论是发消息还是处理消息，都是Handler帮助实现的，所以可以把Handler看做成一个工具类。

 

Handler通常用于：当需要新开线程执行一些耗时的操作时，等到结果返回时，用它来实现UI的更新。

从上面分析可知，要想实现这个，Handler就需要持有UI线程的Looper，这个很容易实现，通过构造函数：

    /**
     * Use the provided queue instead of the default one.
     */
    public Handler(Looper looper) {
        mLooper = looper;
        mQueue = looper.mQueue;
        mCallback = null;
    }

当新开线程运行后，就可以通过这个关联了UI线程的Looper的Handler对象发送消息，然后在通过handlerMessage()在UI线程里更新了：

new Thread(new Runable(){
      @Override
      run(){
        mHandler.sendEmptyMessage(0);
    }   
}
).start()

 

 

注意，很经常我们会这样做：

Runable r = new Runable(){
    run(){
    ......         
    }
}

mHandler.post(r);

理所当然的认为，貌似是新开了一个线程去执行run()里面的方法，因为Runnable的作用太深入人心了，而事实不然，请看：

    /**
     * Causes the Runnable r to be added to the message queue.
     * The runnable will be run on the thread to which this handler is 
     * attached. 
     *  
     * @param r The Runnable that will be executed.
     * 
     * @return Returns true if the Runnable was successfully placed in to the 
     *         message queue.  Returns false on failure, usually because the
     *         looper processing the message queue is exiting.
     */
    public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);//post做得只是这个，就是放松了一条消息那么简单，并没有任何新开一条线程的意思
    }

而Runnable对象究竟有什么用，看getPostMessage(r)：

    private final Message getPostMessage(Runnable r) {
        Message m = Message.obtain();//它就是获取一条新消息
        m.callback = r;//r只是作为了Message对象的callback变量
        return m;
    }

最后r会发生什么作用：

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

callback不为空时，会干什么：

 

    private final void handleCallback(Message message) {
        message.callback.run();
    }

当Handler分发消息时会干什么？它就是执行了Runnable的run()方法，像一般函数一样，奇葩了吧，而且Handler会收不到消息，因为虽然貌似“发送”了，其实没有，只是执行了run方法而已。。。。

所以当你想Handler能够收到消息，请在run()方法中，写上mHandler.sendEmptyMessage(0)。这种形式使用Handler基本是用于按计划发送消息或者执行一个Runnable。

 

最后说一下HandlerThread，HandlerTread继承与Thread，它有什么不同？先看下面：

 

class MyThread extends Thread{
    public Looper looper = null;

    public void run(){
        Looper.prepare();
        looper = Looper.myLoop();
        Looper.loop();}
}            

 

在UI线程（或者是自己的其他 线程中）定义上面这样的一个Thread：

MyThread myThread = new MyThread();
myThread.start();
Looper myLooper = myThread.myLooper();
Handler handler = new Handler(myLooper);
handler.sentEmptyMessage(0);

这种情况极有可能因为线程的同步问题而出错，看代码知，当MyThread.start()后，线程执行到哪里是不可确定的，有可能Looper.prepare()没有执行，这时候，把myThread.myLooper()的值赋给myLooper就是NULL，这样就会出错。所以多线程下的同步还是很重要的，而HandlerThread()就是给我们解决了这个问题，看它重要的两个方法，一个是获得Looper对象的getLooper()，另一个就是run()：

    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            Process.setThreadPriority(mPriority);
            notifyAll();//保证执行完prepare()后，唤醒
        }
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }
    
    /**
     * This method returns the Looper associated with this thread. If this thread not been started
     * or for any reason is isAlive() returns false, this method will return null. If this thread 
     * has been started, this method will block until the looper has been initialized.  
     * @return The looper.
     */
    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }
        
        // If the thread has been started, wait until the looper has been created.
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();//如果mLooper为空，则表明还没有调用prepare方法，就等待
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }

上面注释部分明显看出，HandlerThread解决这种线程同步问题的方案，简单而使用。