原文地址:http://blog.csdn.net/wcs542882916
/**
* 一个Handler允许你去发送和处理Message和Runnable对象,
* 而Message和Runnable对象是与一个线程的MessageQueue相关的。
* 每个Handler实例与一个单独的线程相关且和这个线程的MessageQueue相关。
* 当你创建一个Handler的时候,这个Handler会绑定到创建这个Handler的线程和线程的MessageQueue。
* 从创建Handler开始,Handler将会发送Message 和Runnable到对应的MessageQueue,
* 并且在Message和Runnable被移出MessageQueue的时候处理。
*
*Handler有两个主要用法:
* (1)计划在将来的某个时间点处理Message和Runnable。
* (2)在不同的线程里将一个动作加入Handler所对应的队列去执行,这个线程不只是创建Handler的线程。
*
* 计划Message用以下这些方法来完成,#post,#postAtTime(Runnable,long),
*#postDelayed,#sendEmptyMessage,#sendMessage,
*#sendMessageAtTime,#sendMessageDelayed。
* 这个post版本的方法允许你把Runnable对象加入队列,在Runnable对象移出的时候被MessageQueue调用;
* 这个sendMessage版本的方法允许你把Message对象(Message对象里包含一些数据)加入队列,
* 并且被Handler的#handleMessage方法处理,
* 这个sendMessage版本需要你实现Handler的子类,重写#handleMessage方法。
*
* 当posting 或 sending
* 给Handler时,你能允许这item在MessageQueue准备好后及时的被处理或者指定一个延迟时间,
* 又或者指定一个绝对时间点。
*#sendMessageAtTime,#sendMessageDelayed这两个方法允许你实现延时,定时,和其它基于定时的操作。
*
* 当你的应用进程被创建的时候,应用的主线程就一直致力于运行一个MessageQueue,
* 主线程致力于管理顶级应用对象(activity,broadcast receivers,etc) 和任何创建的窗口。
* 你可以创建你自己的线程,然后通过Handler与应用主线程通信。这种与主线程的通信方式被实现,
* 也是像之前一样同样通过post和sendMessage方法。
*Runnable对象和Message将要被加入Handler的MessageQueue中,在合适的时候被处理。
*
* AHandler allows you to send and process{@link Message} and Runnable objects
*associated with a thread's {@linkMessageQueue}. 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 -- fromthat point on, it will deliver messages and
*runnables to that message queue and execute them as they come out of the
*message queue.
*
*There are two main uses for a Handler: (1) to schedule messages and runnables
* tobe executed as some point in the future; and (2) to enqueue an action to
* beperformed on a different thread than your own.
*
*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 post versions allow you
* toenqueue Runnable objects to be called by the message queue when they are
*received; the sendMessage 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).
*
*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.
*
*When a process is created for your application, its main thread is dedicated
* torunning 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
*post or sendMessage 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.
*/