Android FrameWork 之异步消息处理线程

异步消息处理线程概念：

线程启动后会进入一个无限循环体（Loop）之中，每一次循环，均会从消息队列（MessageQueue）中取出一个消息，并回调对应的处理函数，执行完继续从消息队列中读取，重复执行。直到MessageQueue中无消息时，被阻塞，直到消息队列中有新的消息时，继续读取消息并处理。

消息处理部分源码:

for(;;){
　　//从消息队列中读取下一条消息，如果消息队列为空，则next()方法将会被阻塞；
　　Message msg = queue.next();
　　if(msg != null ){
　　//	msg.target 对应 Handler 的实例
　　if(msg.target == null){
　　//	如果Handler为null，即无法返回具体HanlderMessage方法
　　return ;
　　//	此处部分源码省略……
　　}
　　msg.recycle();
　　}
}

Android的消息处理核心类：

Looper，Handler，Message，MessageQueue。

一段简单Handler用法示例，并对他进行深入分析：

Handler myHandler = new Handler() {  
          public void handleMessage(Message msg) {   
               switch (msg.what) {   
                    case TestHandler.GUIUPDATEIDENTIFIER:   
                         //省略……
                         break;   
               }   
               super.handleMessage(msg);   
          }   
     };

首先创建了Handler，获取当前线程的Looper对象。

如果当前在主线程中创建Handler，则是MainLooper对象；

否则需要调用Looper.prepare()，为当前线程创建MessageQueue对象；　

Looper.class

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

Looper对象中会创建MessageQueue对象，并且每个Looper对象与MessageQueue对象为一一对应关系；

执行Looper.loop()，使当前异步消息处理线程进入无限循环状态；

Looper.class

public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final 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();

        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
		// 省略……
            msg.target.dispatchMessage(msg);//消费掉消息后，将结果回调至指定的Handler对象；
		// 省略……
            msg.recycle();
        }
    }

Handler的构造函数

Handler.class

    public Handler(Callback callback, boolean async) {
        // 省略……
        mLooper = Looper.myLooper();//
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

跟进Looper.myLooper();

ThreadLocal类是模板类，提供了以线程为作用域的变量存储，基本方法（set()&get()）；

Looper.class

  /**
     * Return the Looper object associated with the current thread.  Returns
     * null if the calling thread is not associated with a Looper.
     */
    public static Looper myLooper() {
        return sThreadLocal.get();
    }

实现Handler的CallBack接口，当Message被消费后，将由异步消息处理线程回调该方法。

 /**
     * Callback interface you can use when instantiating a Handler to avoid
     * having to implement your own subclass of Handler.
     *
     * @param msg A {@link android.os.Message Message} object
     * @return True if no further handling is desired
     */
    public interface Callback {
        public boolean handleMessage(Message msg);
    }