Handler+Looper+MessageQueue

来源：http://blog.csdn.net/mylzc/article/details/6771331

消息队列如下：

    
    
    
    
class CustomThread extends Thread {
        @Override
        public void run() {
            //建立消息循环的步骤
            Looper.prepare();//1、初始化Looper
            mHandler = new Handler(){//2、绑定handler到CustomThread实例的Looper对象
                public void handleMessage (Message msg) {//3、定义处理消息的方法
                    switch(msg.what) {
                    case MSG_HELLO:
                        Log.d("Test", "CustomThread receive msg:" + (String) msg.obj);
                    }
                }
            };
            Looper.loop();//4、启动消息循环
        }
    }

消息队列步骤

1、  初始化Looper

2、  绑定handler到CustomThread实例的Looper对象

3、  定义处理消息的方法

4、  启动消息循环

Looper.prepare: 

sThreadLocal.set(new Looper());

Looper.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;
            //}a
            if (msg != null) {
                if (msg.target == null) {
                    // No target is a magic identifier for the quit message.
                    return;
                }
          ... ...
                msg.target.dispatchMessage(msg);
       ... ...
                
                msg.recycle();
            }
        }
    }

　　dispatchMessage:

public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
}

 何为msg.target

Handler.java

    public static Message obtain(Handler h) {
        Message m = obtain();
        m.target = h;

        return m;
    }

 原理表述

andriod提供了 Handler 和 Looper 来满足线程间的通信。Handler 先进先出原则。Looper类用来管理特定线程内对象之间的消息交换

1)Looper: 一个线程可以产生一个Looper对象，由它来管理此线程里的Message Queue(消息队列)。

2)Handler: 你可以构造Handler对象来与Looper沟通，以便push新消息到Message Queue里;或者接收Looper从Message Queue取出)所送来的消息。

3) Message Queue(消息队列):用来存放线程放入的消息。

4)线程：UI thread 通常就是main thread，而Android启动程序时会替它建立一个Message Queue。

取消息队列消息是个循环，

取消息不是阻塞的，当msg为空时会执行MessageQueue.IdleHandler接口消息

MessageQueue.IdleHandler 

参考：http://bbs.51cto.com/thread-1094228-1.html

以用来在线程空闲的时候，指定一个操作；有点类似Handler.postDelayed(Runnable r, long delayMillis),都是在将来的某一个时间
执行一个操作。
不过，使用IdleHandler的好处在于可以不用指定一个将来时间，只要线程空闲了，就可以执行它指定的操作。
比较适合那种需要在将来执行操作，但是又不知道需要指定多少延迟时间的操作。

实现方法：

Looper.myQueue().addIdleHandler(new MessageQueue.IdleHandler() {...}