Handler和Looper

源码路径可以参考：http://androidxref.com/9.0.0_r3/

Handler的注释很精彩：

/**
 * A Handler allows you to send and process {@link Message} and Runnable
 * objects associated with a thread's {@link MessageQueue}.  Each Handler
 * instance is associated with a single thread and that thread's message
 * queue.  When you create a new Handler, it is bound to the thread /
 * message queue of the thread that is creating it -- from that point on,
 * it will deliver messages and runnables to that message queue and execute
 * them as they come out of the message queue.
 *
 * <p>There are two main uses for a Handler: (1) to schedule messages and
 * runnables to be executed as some point in the future; and (2) to enqueue
 * an action to be performed on a different thread than your own.
 *
 * <p>Scheduling messages is accomplished with the
 * {@link #post}, {@link #postAtTime(Runnable, long)},
 * {@link #postDelayed}, {@link #sendEmptyMessage},
 * {@link #sendMessage}, {@link #sendMessageAtTime}, and
 * {@link #sendMessageDelayed} methods.  The <em>post</em> versions allow
 * you to enqueue Runnable objects to be called by the message queue when
 * they are received; the <em>sendMessage</em> versions allow you to enqueue
 * a {@link Message} object containing a bundle of data that will be
 * processed by the Handler's {@link #handleMessage} method (requiring that
 * you implement a subclass of Handler).
 *
 * <p>When posting or sending to a Handler, you can either
 * allow the item to be processed as soon as the message queue is ready
 * to do so, or specify a delay before it gets processed or absolute time for
 * it to be processed.  The latter two allow you to implement timeouts,
 * ticks, and other timing-based behavior.
 *
 * <p>When a
 * process is created for your application, its main thread is dedicated to
 * running a message queue that takes care of managing the top-level
 * application objects (activities, broadcast receivers, etc) and any windows
 * they create.  You can create your own threads, and communicate back with
 * the main application thread through a Handler.  This is done by calling
 * the same <em>post</em> or <em>sendMessage</em> methods as before, but from
 * your new thread.  The given Runnable or Message will then be scheduled
 * in the Handler's message queue and processed when appropriate.
 */

简单概括下就是，Handler有两个用处：可以暂存消息(Message)或者Runnable对象，使得它们可以在未来(基于时间)的时候被处理或者执行；可以把消息(Message)或者Runnable对象放到其他的线程(Thread)上面去执行。

每个 Handler实例和一个线程以及线程上的消息队列(MessageQueue)相关联. 当创建一个新的Handler的时候，它就和创建它的线程以及消息队列绑在一起，并向线程上的消息队列发送消息或者Runnable对象，在消息或者Runnable对象出消息队列的时候被处理或者被运行。

Handler自己无法完成这个功能，必须和Looper一起来完成。

在Handler的几个构造函数中，Looper可以通过参数传递，如果没有通过参数传递，则使用Looper.myLooper()调用返回的Looper。

Looper很特别，它是绑定在thread上面，并且read上面只有一个Looper实例，在这个thread上面发起loop循环。

回到上面Handler的Looper，如果这个Looper是其他thread上面创建的，则Looper在其他的thread上面发起loop循环；如果没有指定这个Looper实例，则在当前thread上面发起loop循环。

Looper有一个MessageQueue mQueue，也会传递给Handler。
Handler把Message的target设置成当前这个Handler, 然后把Message放到这个Messageueue上面。Looper的loop循环会收到这个Message，并调用Message的callback或者调用Handler子类定义的handleMessage（注意，这个callback或者handleMessage是在创建Looper的thread上面运行的，如果这个thread不是UI thread，则在 callback或者handleMessage中不能访问UI元素）。

Handler在发送Message的时候可以设置delay时间，在处理的时候是转换成绝对时间，传递到C代码中，使用epoll_wait，设置其timeout时间来实现的。

从上面可以发现，Looper是一个背后英雄。