Handler机制

我们经常用Handler来更新UI，但是对Handler机制没有一个系统的理解，现在做一个系统的解析。
我们先看一张图：

对，我们就是要理解Handler机制的三大将的关系，即Handler、Looper、Message

• Looper
  Looper主要是prepare()和loop()两个方法。
  （1）prepare()
  prepare() {
  if (sThreadLocal.get() != null) {
  throw new RuntimeException("Only one Looper may be created per thread");
  }
  sThreadLocal.set(new Looper(true));
  }
  sThreadLocal是一个ThreadLocal对象，可以在一个线程中存储变量（副本）。从代码可以看出，Looper.prepare()只能调用一次，否则报错。
  （2）loop()
  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; //拿到该looper实例中的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);  // 把消息交给msg的target的dispatchMessage方法去处理，Msg的target其实是handler对象
  
          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();  
      }  
  }  
  
  public static Looper myLooper() {
      return sThreadLocal.get();
  }
  

从代码可以看出，Looper有2个作用：
1.与当前线程绑定，保证一个线程只会有一个Looper实例，同时一个Looper实例也只有一个MessageQueue。
2.loop()方法，不断从MessageQueue中去取消息，交给消息的target属性的dispatchMessage去处理。

• Handler
  我们看先看一下Handler的其中一个构造函数：
  public Handler(Callback callback, boolean async) {
  if (FIND_POTENTIAL_LEAKS) { // FIND_POTENTIAL_LEAKS 为 false;
  final Class 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(); // 获取当前线程（调用者）的Looper
      if (mLooper == null) { // 如果当前线程没有Looper，则抛异常
          throw new RuntimeException( 
              "Can't create handler inside thread that has not called Looper.prepare()");
      }
      mQueue = mLooper.mQueue; // 这里引用的MessageQueue是Looper()中创建的
      mCallback = callback;
      mAsynchronous = async;
  }
  

从这里我们可以看出，Handler通过Looper.myLooper()获取到当前线程的Looper对象，再通过mLooper.mQueue获取到Looper的消息队列，这样Handler的实例与我们Looper实例中MessageQueue关联上了。
我们看看怎么发消息的。看sendMessage()方法：
public final boolean sendMessage(Message msg) {
return sendMessageDelayed(msg, 0);
}
再看sendMessageDelayed()方法：
public final boolean sendMessageDelayed(Message msg, long delayMillis) {
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
再看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);
}
再看enqueueMessage()方法：
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
sendMessage()最终调用的是enqueueMessage()方法，我们看一下方法实体。enqueueMessage中首先为meg.target赋值为this，也就是把当前的handler作为msg的target属性。最终会调用queue的enqueueMessage的方法，也就是说handler发出的消息，最终会保存到消息队列中去。
之前已经解释了Looper会调用prepare()和loop()方法，在当前执行的线程中保存一个Looper实例，这个实例会保存一个MessageQueue对象，然后当前线程进入一个无限循环中去，不断从MessageQueue中读取Handler发来的消息。然后再回调创建这个消息的handler中的dispathMessage方法，下面我们看一看这个方法：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
我们看到调用了handleMessage()方法，其实是一个空方法：
/**
* Subclasses must implement this to receive messages.
*/
public void handleMessage(Message msg) {
}
为什么是一个空方法呢？因为消息的最终回调是由我们控制的，我们在创建handler的时候都是复写handleMessage方法，然后根据msg.what进行消息处理。
private Handler mHandler = new Handler() {
public void handleMessage(android.os.Message msg) {
switch (msg.what) {
case value:
break;
default:
break;
}
};
};
总结一下
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可以成功创建呢，这是因为在Activity的启动代码中，已经在当前UI线程调用了Looper.prepare()和Looper.loop()方法。

Handler Post方法解析

post方法并没有新建线程，只是发送消息：

  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 重新分配内存。
sendMessageDelayed()方法和sendMessage()方法差不错，原理相似，只是多了个时间参数。

以上是所有Handler机制的整个原理解析，我也是跟着大神的博客理解的，嘻嘻！！