Android 消息机制

异步消息处理

一、Looper

Looper负责的就是创建一个MessageQueue，然后进入一个无限循环体不断从该MessageQueue中读取消息,而消息的创建者就是一个或多个Handler 。

在构造方法中，创建了一个MessageQueue（消息队列）。

private Looper(boolean quitAllowed) {    mQueue = new MessageQueue(quitAllowed);    mThread = Thread.currentThread();}

方法1. static void prepare() 静态的方法，准备
ThreadLocal中添加进一个新的对象，sThreadLocal是一个ThreadLocal对象，可以在一个线程中存储变量。prepare()中判断了当前线程的 Looper 对象是否为null，不为 null则抛出异常。这也就说明了一个线程Looper.prepare()方法不能被调用两次，同时也保证了一个线程中只有一个Looper实例

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();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));}

方法2. loop() 方法

public static Looper myLooper() {    return sThreadLocal.get();}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(); // 可能阻塞，只有当 MessageQueue 调用 quit 方法时，next 方法才会返回 null，否则都会阻塞等待        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);把消息交给msg的target的dispatchMessage方法去处理。        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.recycle();    }}

Looper 的静态方法 prepare() 中新建了一个 Looper 对象，Looper 的构造方法中初始化了 MessageQueue(新建) 、
且为 Thread 对象赋值(当前线程)。这两个对象是 Looper 对象持有的，每个 Looper 对象中都有一个 MessageQueue 和 当前线程对象，

prepare() 中将新建的 Looper 对象添加到了 ThreadLocal 对象中，这个对象是
static final ThreadLocal sThreadLocal = new ThreadLocal();
ThreadLocal 在类的最初就会实例化，在存储 Looper 的时候会以当前线程的对象作为一个参数，在取Looper
时也会通过当前线程来取

prepare() 方法中会判断当前线程是否已经绑定了 Looper 对象，如果绑定了则会抛出
throw new RuntimeException(“Only one Looper may be created per thread”);

在初始化 Handler 时也会根据当前线程判断是否绑定了 Looper ，如果没有绑定则会抛出
throw new IllegalStateException(“No Looper; Looper.prepare() wasn’t called on this thread.”);
通过这个过程，保证了每个线程只能绑定一个 Looper ，并且每个 Looper 都有一个 MessageQueue 对象

Looper.myLooper()获取了当前线程保存的 Looper 实例，然后在又获取了这个 Looper 实例中保存的
MessageQueue（消息队列），这样就保证了 handler 的实例与我们 Looper 实例中 MessageQueue 关联上了。

Looger.getMainLooper(); 获取主线程的 Looper 对象，主线程会自动调用 Looper.prepareMainLooper() 方法
完成 Looper 对象的绑定，并将该 Looper 对象赋值给一个静态的 Looper 变量，在调用 getMainLooper() 方法
时将该 Looper 对象返回。

Looper.myLooper() 方法是获取当前线程的 Looper 对象。

MessageQueue 的 next() 方法

MessageQueue 的 next() 方法中，除了取出 Java 层需要处理的 Message 对象，还会调用 nativePollOnce() 方法处理 Native 层的消息循环

native 层的消息循环在 MessageQueue 构造函数执行时启动，其构造函数会在 Native 层创建 Native.Looper 和 NativeMessageQueue,通过 Linux 的管道和 epoll 机制来实现

Linux 的管道可以看做是一个文件，并且包含读和写端，epoll 机制是如果一个线程读该文件时该文件没有内容，则该线程会进入等待，当另一个线程往该文件写内容后会唤醒正在读端等待的线程。这个等待和唤醒的机制就使用 Linux 的 epoll 机制

当 Java 层的 MessageQueue 获取消息的时候，也会调用 natice 层的 MessageQueue 从管道中读消息并且处理消息

创建 Native 层循环模型的原因：
Android 是支持纯 Native 开发的，并且 Android 系统的核心组件也是运行在 native 层的，各组件直接需要通信，所以建立两套循环机制就很重要

Looper主要作用：

1. 与当前线程绑定，保证一个线程只会有一个 Looper 实例，同时一个 Looper 实例也只有一个 MessageQueue

2. loop() 方法，不断从 MessageQueue 中去取消息，交给消息的 target 属性的 dispatchMessage 去处理

好了，我们的异步消息处理线程已经有了消息队列（MessageQueue），也有了 Looper 在无限循环体中取出消息，
现在缺的就是发送消息的对象了，发送消息的对象是 Handler

二、Handler

---

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

Handler 对象中有一个 Looper 对象和一个 MessageQueue 对象，这两个属性都是final 的在创建一个 Handler 对象的时候，如果当前线程没有绑定 Looper 对象，则会抛出异常 throw new RuntimeException(“Can’t create handler inside thread that has not called Looper.prepare()”);所以在一个线程中创建 Handler 的时候当前线程必须调用 Looper.prepare(); 方法

然后看我们最常用的sendMessage方法,方法最后调用了sendMessageAtTime，在此方法内部有直接
获取 MessageQueue 然后调用了 enqueueMessage 方法，我们再来看看此方法： enqueue : 入队

    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {         msg.target = this;         if (mAsynchronous) {             msg.setAsynchronous(true);         }         return queue.enqueueMessage(msg, uptimeMillis);      }

enqueueMessage 中首先为 meg.target 赋值为this，【Looper的loop方法会取出每个msg然后交给 msg.target.dispatchMessage(msg) 去处理消息，也就是把当前的handler作为msg的 target 属性。

最终会调用 queue 的 enqueueMessage 的方法，也就是说 handler 发出的消息，最终会保存到消息队列中去。enqueueMessage 方法中使用 synchronize 锁 MessageQueue 对象，保证不同线程插入数据时的同步问题。

Looper 会调用 prepare() 和 loop() 方法，在当前执行的线程中保存一个 Looper 实例，这个实例会保存一个 MessageQueue 对象，然后当前线程进入一个无限循环中去，不断从 MessageQueue 中读取 Handler 发来的消息。然后再回调创建这个消息的 handler 中的 dispathMessage 方法

    public void dispatchMessage(Message msg) {          if (msg.callback != null) {              handleCallback(msg); // 使用创建 Message 时构造方法中的 Runnable 处理消息        } else {              if (mCallback != null) {                  if (mCallback.handleMessage(msg)) {  // 使用创建 Handler 时构造方法中的 Handler.Callback 处理消息                    return;                  }              }              handleMessage(msg);  // 重写的处理消息方法处理        }      } 

这个流程已经解释完毕，让我们首先总结一下

1. 首先Looper.prepare()在本线程中保存一个Looper实例，然后该实例中保存一个MessageQueue对象； 因为Looper.prepare()在一个线程中只能调用一次，所以MessageQueue在一个线程中只会存在一个。

2. Looper.loop()会让当前线程进入一个无限循环，不断从 MessageQueue 的实例中读取消息，然后回调 msg.target.dispatchMessage(msg) 方法。

3. Handler 的构造方法，会首先得到当前线程中保存的 Looper 实例，进而与 Looper 实例中的 MessageQueue 相关联。

4. Handler的 sendMessage 方法，会给 msg 的 target 赋值为 handler 自身，然后加入 MessageQueue 中。

5. 在构造 Handler 实例时，我们会重写 handleMessage 方法，也就是 msg.target.dispatchMessage(msg) 最终调用的方法。

好了，总结完成，大家可能还会问，那么在Activity中，我们并没有显示的调用 Looper.prepare() 和 Looper.loop() 方法，
为啥 Handler 可以成功创建呢，这是因为在 ActivityTherad 的 main() 方法中，已经为主线程调用了Looper.prepareMainLooper() 和 Looper.loop() 方法。

关于Handler处理消息的方式

1. 创建 Message 对象时，指定 Runnable 对象，
   例如 Message.obtain(Handler handler, Runnable callback)

2. 创建 Handler.Callback 实现类对象，并作为创建 Handler 的构造方法的参数

3. 自定义类继承自 Handler，并重写 handlerMessage() 方法

以上3种方法的执行顺序：如果存在方式1，则由方式1直接处理；如果存在方式2，则方式2处理消息，且，如果方式2返回true，则处理完毕，否则，方式3也会处理消息。

Handler.post(); // 等多久执行… run() 方法中的代码

mHandler.post(new Runnable() {      @Override          public void run(){          og.e("TAG", Thread.currentThread().getName());          mTxt.setText("test");      }  });  

然后 run 方法中可以写更新UI的代码，其实这个 Runnable 并没有创建什么线程，而是发送了一条消息，下面看源码：

public final boolean post(Runnable r)  {    return  sendMessageDelayed(getPostMessage(r), 0);  }  private static Message getPostMessage(Runnable r) {    Message m = Message.obtain();    m.callback = r;    return m;  }   

可以看到，在 getPostMessage 中，得到了一个 Message 对象，然后将我们创建的 Runable 对象作为 callback 属性，赋值给了此 message.
- 注：产生一个Message对象，可以new ，也可以使用Message.obtain()方法；两者都可以，但是更建议使用obtain方法，
因为Message内部维护了一个Message池用于Message的复用，避免使用new 重新分配内存。
最终和handler.sendMessage一样，调用了sendMessageAtTime，然后调用了enqueueMessage方法，给msg.target赋值为 handler，最终加入MessagQueue.

• msg的 callback 和target都有值，那么会执行哪个呢？
  如果 callback 不为null，则执行callback回调，也就是我们的Runnable对象

• Handler 对象创建之后可以在任何线程中发消息，最终消息的处理都将回到 创建 Handler 时使用的 Looper 所在的线程处理。所以在子线程中可以使用主线程中创建的 Handler 对象发消息，在主线程中处理消息。

每个线程中可以创建多个 Handler ，处理消息时就调用 msg.targe 也就是 Handler 来处理，Looper 将消息发送给发送消息时使用的 Handler 对象来处理。子线程不可以直接创建 Handler， 必须在子线程先调用 Looper.prepare();线程中调用 Looper.loop(); 方法后才会开启轮循

一个线程中只能有一个 Looper ，也就是只能有一个 MessageQueue ，可以有多个 Handler。一个 Handler 可以在不同的线程中发送消息，但是消息的处理都是在创建 Handler 时使用的 Looper 所在的线程

总结

每个线程在绑定 Looper 之后都有一个 MessageQueue ，MessageQueue 中存着需要处理的消息 Message，Message 中存着处理消息的 Handler，Handler 在发消息时会将消息发送到自己所在线程的 MessageQueue，Looper 的 loop 方法就是开启 MessageQueue 的遍历。这样，Handler 所发的消息处理就会在 Handler 所在的线程中。

参考：http://blog.csdn.net/lmj623565791/article/details/47079737