Handler 消息传递机制

1，Handler 的概念

Handler 是用来干什么的？

1）执行计划任务，可以在预定的时间执行某些任务，可以模拟定时器

2）线程间通信。在Android的应用启动时，会创建一个主线程，主线程会创建一个

消息队列来处理各种消息。当你创建子线程时，你可以在你的子线程中拿到父线程中

创建的Handler 对象，就可以通过该对象向父线程的消息队列发送消息了。由于Android

要求在UI线程中更新界面，因此，可以通过该方法在其它线程中更新界面。

角色描述：

1） Looper: 一个线程可以产生一个Looper对象，由它来管理此线程里的Message Queue

2） Handler: 你可以构造Handler对象来与Looper沟通，以便push 新消息到 Message Queue里，或者

接收Looper从Message Queue 里所送来的消息。

3）Message Queue（消息队列）：是用来存放线程放入的消息。

4）线程：UI thread 通常就是 main thread，而Android 启动程序时会替它建立一个Message Queue。

每一个线程里可含有一个 Looper 对象以及一个 Message Queue 数据结构。在你的应用程序里，

可以定义 Handler 的子类别来接收 Looper 所送出的消息。

2，Handler 的执行过程

 


每个handler 对应一个线程 thread ,  在子线程中 handler 发送的消息会进入到 Message Queue当中去，由 looper 再来分发给 Handler 处理。

3，Handler 异步实现方法

见实例

http://download.csdn.net/detail/fulinwsuafcie/4437306

4，Handler 与线程的关系

Handler 一般运行于主线程内

问题：

1，使用Handler 是异步的，它会建立新的线程么？ 不会

2，Handler 是在主线程内么？ 一般都会在主线程内，但也可以在子线程中创建Handler

3，Handler 的 post 和 sendMessage 方法，使用的是一个队列不安是两个？ 一个

4，子线程中建立一个 handler, 然后sendMessage 会怎么样？ 会崩溃

5，子线程建立 handler ,构造的时候舒心入主线程的 Looper ? yes

 

如果有兴趣的话，可以看下原始的android 注释，摘自 Handler.java 代码的头部注释。

/**

 * 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.

 */