Handler 、 Looper 、Message

分析：

Looper：prepare和loop

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

由上述方法可知，第5行新建一个Looper实例然后添加到sThreadLocal中，上面首先判断sThreadLocal是否为空，若不为空则抛出异常，说明Looper.prepare()方法不能被调用两次，同时也保证了一个线程中只有一个Looper实例

Looper的构造方法：

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

由第2行可知创建了一个MessageQueue消息队列

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.recycle();
         }
 }

第2行调用myLooper()：其源码为

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

Return the Looper object associated with the current thread.返回与当前线程相关联的looper对象赋给me，如果me为null则抛异常，表示looper方法必须在prepare方法之后运行

注：但是有一个疑问：首先贴上我们平常创建handler的代码：

 public class MainActivity extends Activity {

     private Handler handler1;

     private Handler handler2;

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         handler1 = new Handler();
         new Thread(new Runnable() {
             @Override
             public void run() {
                 handler2 = new Handler();
             }
         }).start();
     }

 }

运行会发现在子线程中创建的Handler是会导致程序崩溃的，提示的错误信息为 Can't create handler inside thread that has not called Looper.prepare() 。说是不能在没有调用Looper.prepare() 的线程中创建Handler，所以在里面添加Looper.prepare(); 该行代码后就正常了，但是主线程中也没有添加改行代码，为何就不崩溃呢？原因在于程序启动的时候，系统已经帮我们自动调用了Looper.prepare()方法，上ActivityThread中的main()方法的源码：

 public static void main(String[] args) {
     SamplingProfilerIntegration.start();
     CloseGuard.setEnabled(false);
     Environment.initForCurrentUser();
     EventLogger.setReporter(new EventLoggingReporter());
     Process.setArgV0("<pre-initialized>");
     Looper.prepareMainLooper();
     ActivityThread thread = new ActivityThread();
     thread.attach(false);
     if (sMainThreadHandler == null) {
         sMainThreadHandler = thread.getHandler();
     }
     AsyncTask.init();
     if (false) {
         Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread"));
     }
     Looper.loop();
     throw new RuntimeException("Main thread loop unexpectedly exited");
 }

由第7行可知调用了 Looper.prepareMainLooper();方法，而该方法又会去调用Looper.prepare()方法：

 public static final void prepareMainLooper() {
     prepare();
     setMainLooper(myLooper());
     if (Process.supportsProcesses()) {
         myLooper().mQueue.mQuitAllowed = false;
     }
 }

第2行可知，至此搞清楚了我们应用程序的主线程中会始终存在一个Looper对象，从而不需要再手动去调用Looper.prepare()方法

第6行：拿到该looper实例中的mQueue（消息队列）
13到45行：就进入了我们所说的无限循环。
14行：取出一条消息，如果没有消息则阻塞。
27行：使用调用 msg.target.dispatchMessage(msg);把消息交给msg的target的dispatchMessage方法去处理。Msg的target是什么呢？其实就是handler对象，下面会进行分析。
44行：释放消息占据的资源。

由上述分析可知;Looper主要作用：
1、 与当前线程绑定，保证一个线程只会有一个Looper实例，同时一个Looper实例也只有一个MessageQueue。
2、 loop()方法，不断从MessageQueue中去取消息，交给消息的target属性的dispatchMessage去处理。

异步消息处理线程已经有了消息队列（MessageQueue）,同时也就有了从消息队列中取对象的东东了(Looper)，接下来就是发送消息的Handler

Handler：

我们在使用Handler是都是直接在UI线程中直接new一个实例，具体他是如何跟子线程中的MessageQueue联系上并发送消息的的呢？直接上源码

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

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

平常我们是如何在子线程中发送消息的呢？

 new Thread(new Runnable() {
     @Override
     public void run() {
         Message message = new Message();
         message.arg1 = 1;
         Bundle bundle = new Bundle();
         bundle.putString("data", "data");
         message.setData(bundle);
         handler.sendMessage(message);
     }
 }).start();

由第9行可知我们调用了sendMessage方法，于是我们来看看该方法的源码：

    public final boolean sendMessage(Message msg)
     {
         return sendMessageDelayed(msg, 0);
     }

转而会去调用sendMessageDelayed(msg, 0);方法：

    public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
         Message msg = Message.obtain();
         msg.what = what;
         return sendMessageDelayed(msg, delayMillis);
     }

  public final boolean sendMessageDelayed(Message msg, long delayMillis)
     {
         if (delayMillis < 0) {
             delayMillis = 0;
         }
         return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
     }

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

附新的版本：

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

由上可知Handler中提供了很多个发送消息的方法，其中除了sendMessageAtFrontOfQueue()方法之外，其它的发送消息方法最终都会辗转调用到sendMessageAtTime()方法中，查看该方法源码可知：该方法在内部直接获取了MessageQueue的实例，然后返回调用了enqueueMessage方法，

由第2行代码可知mQueue实例是在Looper的构造方法中创建的消息队列实例对象， 它调用了enqueueMessage方法，可知它是一个消息队列，用于将所有收到的消息以队列的形式进行排列，并提供入队和出队的方法。这个类是在Looper的构造函数中创建的，因此一个Looper也就对应了一个MessageQueue。

接着去查看该方法源码：

  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发出的消息，最终会保存到消息队列中去

现在已经很清楚了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);
         }
     }

可以看到，第10行，调用了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)最终调用的方法。

整个异步处理流程如下图所示：

另外除了发送消息之外，我们还有以下几种方法可以在子线程中进行UI操作：

1. Handler的post()方法

2. View的post()方法

3. Activity的runOnUiThread()方法

我们先来看下Handler中的post()方法，代码如下所示：

原来这里还是调用了sendMessageDelayed()方法去发送一条消息啊，并且还使用了getPostMessage()方法将Runnable对象转换成了一条消息，我们来看下这个方法的源码：

在这个方法中将消息的callback字段的值指定为传入的Runnable对象。咦？这个callback字段看起来有些眼熟啊，喔！在Handler的dispatchMessage()方法中原来有做一个检查，如果Message的callback等于null才会去调用handleMessage()方法，否则就调用handleCallback()方法。那我们快来看下handleCallback()方法中的代码吧：

也太简单了！竟然就是直接调用了一开始传入的Runnable对象的run()方法。因此在子线程中通过Handler的post()方法进行UI操作就可以这么写：

虽然写法上相差很多，但是原理是完全一样的，我们在Runnable对象的run()方法里更新UI，效果完全等同于在handleMessage()方法中更新UI。

然后再来看一下View中的post()方法，代码如下所示：

 public boolean post(Runnable action) {
     Handler handler;
     if (mAttachInfo != null) {
         handler = mAttachInfo.mHandler;
     } else {
         ViewRoot.getRunQueue().post(action);
         return true;
     }
     return handler.post(action);
 }

原来就是调用了Handler中的post()方法，我相信已经没有什么必要再做解释了。

最后再来看一下Activity中的runOnUiThread()方法，代码如下所示：

如果当前的线程不等于UI线程(主线程)，就去调用Handler的post()方法，否则就直接调用Runnable对象的run()方法。还有什么会比这更清晰明了的吗？

附：关于obtainMessage():

对于handler.obtainMessage()的分析：

  /**
      * Returns a new {@link android.os.Message Message} from the global message pool. More efficient than
      * creating and allocating new instances. The retrieved message has its handler set to this instance (Message.target == this).
      *  If you don't want that facility, just call Message.obtain() instead.
      */
     public final Message obtainMessage()
     {
         return Message.obtain(this);
     }

   /**
      * Same as {@link #obtain()}, but sets the value for the <em>target</em> member on the Message returned.
      * @param h  Handler to assign to the returned Message object's <em>target</em> member.
      * @return A Message object from the global pool.
      */
     public static Message obtain(Handler h) {
         Message m = obtain();
         m.target = h;

         return m;
     }

 /**
      * Return a new Message instance from the global pool. Allows us to
      * avoid allocating new objects in many cases.
      */
     public static Message obtain() {
         synchronized (sPoolSync) {
             if (sPool != null) {
                 Message m = sPool;
                 sPool = m.next;
                 m.next = null;
                 sPoolSize--;
                 return m;
             }
         }
         return new Message();
     }

从上面源码可知：obtainMessage()会在内部调用obtain(Handler h) ，接着会在内部调用Message m = obtain();而从obtain()源码中可以看出它会首先从全局消息池中取出message实例，如果池中没有时才会创建新的Message实例，所以在性能上会比直接new Message对象更好一些