Android异步消息处理机制解析

概述

由于Handler总是依附于创建时所在的线程，比如我们的Handler是在主线程中创建的，而在子线程中又无法直接对UI进行操作，于是我们就通过一系列的发送消息、入队、出队等环节，最后调用到handleMessage()方法中，这时的handleMessage()方法已经是在主线程中运行的，因而我们当然可以在这里进行UI操作了。整个异步消息处理流程的示意图如下图所示：

1.Message：
Message定义一个消息包含一个描述和任意的数据对象,可以发送给一个Handler。Android 更推荐我们通过Message.obtain()或者Handler.obtainMessage()获取Message对象。这样先从消息池中看有没有可用的Message实例，存在则直接取出并返回这个实例。反之如果消息池中没有可用的Message实例，则根据给定的参数new一个新Message对象。
2.MessageQueue:
消息队列，用来存放Message对象的数据结构,其中Message对象以链表的方式串联起来的。Looper对象对其进行管理，一个线程最多只可以拥有一个 MessageQueue。我们可以通过Looper.myQueue()获取当前线程中的MessageQueue。
3.Looper：
Looper是用于给一个线程添加一个消息队列(MessageQueue)，并且循环等待，当有消息时会唤起线程来处理消息的一个工具，直到线程结束为止。通常情况下不会用到Looper，因为对于Activity，Service等系统组件，Frameworks已经为我们初始化好了线程(俗称的UI线程或主线程)，在其内含有一个Looper，和由Looper创建的消息队列
4.Handler:
一个Handler允许你发送和处理一个与一个线程的MessageQueue相关联的Message和Runnable对象。当你创建一个新的Handler实例 ,它被绑定到创建它的线程/消息队列的线程——从那时起,它将处理这个MessageQueue 里面的消息和runnables,执行MessageQueue 面出来的消息。
除了发送消息之外，我们还有以下几种方法可以在子线程中进行UI操作：
① Handler的post()/postDelay()方法
② View的post(Runnable)/postDelay(Runnable,long)方法
③Activity的runOnUiThread(Runnable)方法
这几种方法的原理均为异步消息处理机制

---

源码分析

1.Handler的创建：

public Handler() {
        this(null, false);
    }
public Handler(Callback callback, boolean async) {
        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();
        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;
    }

由此可见，若mLooper为空，将会抛出运行时异常，进而无法正确创建Handler对象,而且还告诉我们应该调用Looper.prepare()。那么，我们先进入Looper.myLooper()方法内部看一看：

public static Looper myLooper() {
        return sThreadLocal.get();
    }

很显然，Looper对象是从sThreadLocal中取出。我们再看一看Looper.prepare()方法：

public static void prepare() {
        prepare(true);
    }

    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.prepare()方法为sThreadLocal设置了唯一的Looper，使得Handler可以成功创建。而主线程中，在程序启动的时候，系统已经帮我们自动调用了Looper.prepare()方法。
小结：在主线程中可以直接创建Handler对象，而在子线程中需要先调用Looper.prepare()才能创建Handler对象。

2.发送消息
Handler在发送消息时，内部基本都会调用到sendMessageAtTime()方法，我们进去瞧一瞧：

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        MessageQueue queue = mQueue;
        if (queue == null) {
            RuntimeException e = new RuntimeException(
                    this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
            return false;
        }
        return enqueueMessage(queue, msg, uptimeMillis);
    }

sendMessageAtTime()方法接收两个参数，其中msg参数就是我们发送的Message对象，而uptimeMillis参数则表示发送消息的时间(若调用的不是sendMessageDelayed()方法，延迟时间就为0)，然后将这两个参数都传递到MessageQueue的enqueueMessage()方法中，即入队操作，将消息进入到消息队列MessageQueue中。
入队有了，那么出队呢？就得看看Looper.loop()方法：

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

            // This must be in a local variable, in case a UI event sets the logger
            Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            msg.target.dispatchMessage(msg);

            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }

            // Make sure that during the course of dispatching the
            // identity of the thread wasn't corrupted.
            final long newIdent = Binder.clearCallingIdentity();
            if (ident != newIdent) {
                Log.wtf(TAG, "Thread identity changed from 0x"
                        + Long.toHexString(ident) + " to 0x"
                        + Long.toHexString(newIdent) + " while dispatching to "
                        + msg.target.getClass().getName() + " "
                        + msg.callback + " what=" + msg.what);
            }

            msg.recycleUnchecked();
        }
    }

可知，queue.next()方法即为出队操作。有一个重要的方法：msg.target.dispatchMessage(msg)
msg.taget即为Handler

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

如果mCallback不为空，则调用mCallback的handleMessage()方法，否则直接调用Handler的handleMessage()方法，并将消息对象作为参数传递过去。

标准的异步消息处理线程

 class LooperThread extends Thread {
      public Handler mHandler;
    //private Looper mLooper;
      public void run() {
          Looper.prepare();
          //可加上：mLooper = Looper.myLooper();
          mHandler = new Handler() {    //可改为：mHandler = new Handler(mLooper){}
              public void handleMessage(Message msg) {
                  // process incoming messages here
              }
          };

          Looper.loop();
      }
  }