Android的消息机制: Message/MessageQueue/Handler/Looper

概览

 

* Message：消息。消息里面可包含简单数据、Object和Bundle，还可以包含一个Runnable（实际上可看做回调）。

* MessageQueue：消息队列，供Looper线程消费消息。

* Looper：用于循环处理Message，一个Thread结合一个Looper来实现消息循环处理。Android App的主线程包含了Looper。

* Handler：负责向当前Looper线程发送Message，并实现如何处理消息的回调，回调可放到Callback接口的实现中，也可以放在传递进去的Runnable中的run中。

 

 

消息处理流程

 

1. MainThread（一个Looper Thread）正在运行，线程中有MessageQueue可交互，并循环处理MessageQueue中的Message。

2. 在MainThread中创建一个Handler，handler与当前线程Looper的MessageQueue绑定。

3. 通过handler.sendMessage(Message msg)向MessageQueue发送消息，等候执行；通过handler.post(Runnable r)向MessageQueue发送一个空消息，该空消息附加了Runnable，等候执行。

4. MainThread轮询MessageQueue的Message，抛给Message对应的Handler执行。

 

---

Message

 

* 最好通过Message.obtain()来创建Message对象，从消息池里创建Message更高效。

 

源码分析

public final class Message implements Parcelable

{

     public int what; // 用户定义的标识码

     public int arg1; // 用来存储简单的数据，这样可以不使用Object/Bundle来做消息。

     public int arg2;

     public Object obj; // 对象型数据。

     public Messenger replyTo; 

     Bundle data; // 复杂型消息数据

     // Message的最终处理分两种情况：

     Handler target; // 1)通过Message的target（Handler）处理消息，具体是Handelr实现handleMessage()。

     Runnable callback; // 2)通过空消息的callback（Runnable）处理消息，具体是丢弃Message，然后直接调用run()。

     private static final Object sPoolSync = new Object(); // 消息池用到的锁

     private static Message sPool ; // 从消息池中取出的可用的消息对象。每取一次，这里就放置一个可用的。

     private static int sPoolSize = 0; // 当前可用的消息对象数量

     private static final int MAX_POOL_SIZE = 50 ;  // 池存放最大量

     Message next; // 实现链表式消息池

 

     // 从消息池中取一个可用的消息对象

     public static Message obtain() {

          synchronized (sPoolSync) {

            if (sPool != null) {

                Message m = sPool;

                sPool = m.next;

                m.next = null; 

                sPoolSize--;

                return m;

            }

          }

          return new Message();

     }

 

     // 从现有Message复制并返回

    public static Message obtain(Message orig) {

        Message m = obtain();

        m.what = orig.what;

        m.arg1 = orig.arg1;

        m.arg2 = orig.arg2;

        m.obj = orig.obj;

        m.replyTo = orig.replyTo;

        if (orig.data != null) {

            m.data = new Bundle(orig.data);

        }

        m.target = orig.target;

        m.callback = orig.callback;

 

        return m;

    }

 

     // 发送消息 

     public void sendToTarget() {

          target.sendMessage(this); // 调用的是 handler 的 sendMessage()

     }

 

     // 消息回收

     public void recycle() {

          clearForRecycle(); // 清除Message对象的所有信息

          synchronized (sPoolSync) {

               if(sPoolSize < MAX_POOL_SIZE){

                    next = sPool; // 下一个可用Message是当前sPool（可用）

                    sPool = this ; // 当前可用的Message为正在释放清除的Message对象

                    sPoolSize++; // 可用对象数量递增

               }

          }

     }

}

 

 

MessageQueue

 

* holding the list of messages to be dispatched by a Looper。

* 不能直接向Looper的MessageQueue添加Message，需要通过Handler。

* 可通过 Looper.myQueue()获取到当前线程的MessageQueue。

 

---

Handler

 

* 创建一个Handler就会绑定到当前Thread/MessageQueue，之后，Handler可以向MessageQueue发送Message和Runnable，等候轮询执行。

* 发送一个Message：sendMessage(Message m)。

* 发送一个Runnable：post(Runnable r) 。

 

 

public class Handler

{

     // 自定义的Handler必须实现该方法，用于处理消息

     public void handleMessage(Message msg){}

     // 或者指定一个实现了Callback接口的类

     public interface Callback {

          public boolean handleMessage(Message msg);

     }

 

     // 构造函数

     // 默认情况下，handler会关联到当前Thread的Looper，如果没有Looper，抛异常

     public Handler(Looper looper,Callback callback/*相当于指定了handleMessage()函数*/,boolean async){ 

          mLooper=looper; mQueue=looper.mQueue; mCallback =callback;mAsynchronous = async;

     }

 

     public final Message obtainMessage(){ return Message.obtain(this); } // 直接调用的Message的obtain

 

     // ---------------------------------------------------------------

     // 发送消息到MessageQueue

     // handler.sendXXX均调用此方法

     public boolean sendMessageAtTime(Message msg,long uptimeMillis) {

          MessageQueue queue = mQueue;

          return enqueueMessage(queue,msg,uptimeMillis);

     }

     private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {

        msg.target = this;

        if (mAsynchronous) {msg.setAsynchronous(true);}

        return queue.enqueueMessage(msg, uptimeMillis);

     }

 

     // ---------------------------------------------------------------

     // 发送Runnable到MessageQueue

     // 原理是把Runnable附加到一个空消息的callback上，当执行消息时，如果发现有callback，则执行callback。

     public final boolean post(Runnable r) {

          return sendMessageDelayed(getPostMessage(r),0);

     }

 

     private static getPostMessage(Runnable r,Object token) {

          Message m = Message.obtain();

          m.obj = token;

          m.callback = r; // 指定Message的callback为r。通过sendMessage的消息没有callback，包含callback的Message将会被其callback执行。

          return m;

     }

 

     // ---------------------------------------------------------------

     // 处理消息

     // 消息在Looper中是通过调用这个函数来实现处理消息的

     public void dispatchMessage(Message msg) {

          if(msg.callback!=null){ handleCallback(msg); } // 在Runnable中处理

          else {

               handleMessage(msg); // 调用Handler处理消息的函数

          }

     }

     private static void handleCallback(Message message) { 

          message.callback.run(); //消息被丢弃，并且直接调用run()，而不是新开线程。

      }

 

 

}// end handler()

 

---

Looper

 

* 默认线程并没有包含可以循环处理消息的功能，Looper类可以帮助线程实现消息循环。

 

public final class Looper

{

     static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>(); // 线程本地变量，每个线程一个Looper。

 

     final Message mQueue;

     final Thread mThread;

 

     private Looper(boolean quitAllowed){

          mQueue = new MessageQueue(quitAllowed);

          mThread = Thread.currentThread();

     }

 

     // --------------------------------------------------------------------

     // 准备。为当前线程创建一个Looper对象

     static void prepare(boolean quitAllowed/*MessageQueue是否可退出*/) {

          if(sThreadLocal.get()!=null){/*Exception，当前线程的Looper已存在，一个线程一个Looper*/}

          sThreadLocal.set(new Looper(quitAllowed));

     }

 

     // --------------------------------------------------------------------

     // 开始循环

     public static void loop() {

          final Looper me = myLooper();// 当前线程的Looper实例

          final MessageQueue queue = me.mQueue;

          for(;;){

               Message msg = queue.next();

               if(msg == null) { return;}

 

               msg.target.dispatchMessage(msg); // 由Handler处理该消息

 

               msg.recycle(); // 清理该消息，清空后返回消息池。

 

          }//end for

     }// end loop()

 

     // --------------------------------------------------------------------

     public void quit() { mQueue.quit(false); }

     public boolean isIdling(){ return mQueue.isIdling();}

 

} // class end.

 

 

 

---

Demo

 

Demo#1 发送消息
class SomeActivity
{
　　@Override
　　public void onCreate(...){
　　testMessage();
}

void testMessage(){
　　MyHandler handler = new MyHandler();
　　// or
　　handler = new Handler(/*this.getMainLooper(),*/ new Handler.Callback(){ /*...*/ });

　　// 发送Message
　　Message m1 = new Message();
　　m.setTarget(h);
　　m.sendToTarget();

　　// 发送Runnable（内部其实是发送了一个Message+Runnable）
　　handler.post(new Runnable(){
　　　　@Override
　　　　public void run(){
　　　　　　// 在主线程中运行
　　　　}
　　});
}

class MyHandler extends Handler{
　　@Override
　　public void handleMessage(Message msg){ /*...*/ }
}

Demo#2 自定义Looper线程
public static void testLooper()
{
　　Thread tLooper = new Thread(new Runnable(){

　　@Override
　　public void run() {
　　　　Looper.prepare();

　　　　MyHandler h = new MyHandler();
　　　　// 发送消息
　　　　h.sendEmptyMessage(0);
　　　　// 发送Runnable
　　　　h.post(new Runnable(){
　　　　　　@Override
　　　　　　public void run() {
　　　　　　Log.i("test","[in post runnable]threadid:"+Thread.currentThread().getId()); // tLooper线程ID
　　　　}});

　　　　Looper.loop(); // 一直循环。即使没有消息
　　}});
　　tLooper.start();
}

 

---

references

 

http://developer.android.com/reference/android/os/MessageQueue.html 

http://developer.android.com/reference/android/os/Looper.html