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 消息传递机制_第1张图片

每个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.
 */
 

 

你可能感兴趣的:(thread,数据结构,android,application,任务,methods)