Android Handler 消息循环机制

前言

一问起Android应用程序的入口,很多人会说是Activity中的onCreate方法,也有人说是ActivityThread中的静态main方法。因为Java虚拟机在运行的时候会自动加载指定类的静态共有main方法,因此个人更倾向于第二种说法。

  1. public final class ActivityThread {


  2. ...... 

  3. public static void main(String[] args) { 

  4. ...... 

  5. Looper.prepareMainLooper(); 

  6. ActivityThread thread = new ActivityThread(); 

  7. thread.attach(false); 

  8. if (sMainThreadHandler == null) { 

  9. sMainThreadHandler = thread.getHandler(); 



  10. ...... 

  11. Looper.loop(); 

  12. throw new RuntimeException("Main thread loop unexpectedly exited"); 





我们注意到这段代码,先调用Looper的prepareMainLooper()方法,新建一个ActivityThread,然后再获取MainThreadHander,最后调用Looper.loop()方法,程序就一直在loop方法中循环。Looper,Handler之间有何关系?请看下文。

程序的消息循环

  1. class test {


  2. public static void main (String[] args) { 

  3. System.out.println("hello world!"); 





上述小程序就是一个任务,虚拟机启用一个线程执行完该任务后,程序就结束了。为了保证程序不立即退出,一般都会写一个循环

  1. class test {


  2. public static void main (String[] args) { 

  3. while (hasNextMessage()) { 

  4. msg = getMessage() ;  

  5. handleMessage(msg) ; 







系统不断从getMessage获取消息,再通过handleMessage来处理消息。这种基于消息的循环模型在许多的系统框架中都有实现。比如iOS系统中的RunLoop,再比如windows系统中的消息队列,windows系统会为每一个UI线程分配一个消息队列,发生输入事件后,windows将事件转换为一个"消息"发送给系统消息队列,操作系统有一个专门的线程从系统消息队列中取出消息,分发给各个UI线程的输入消息队列中。Android中的应用系统框架也不例外,也有一套自己的消息循环机制,这套机制是靠Looper、Handler、MessageQueue来共同完成的。

原理

p1.jpg

图片来自zongpeiqing的CSDN博客。Looper负责消息循环(例子中的while语句),Handler负责发送和处理消息,MessageQueue则负责管理消息(消息的增加和移除)。不管是sendMessage还是sendMessageDelay或是View.post方法,或是上面列出的没列出的发送消息的方法,最终都会包装成一条消息Message(这条消息由Handler发出),然后调用MessageQuque的enqueueMessage方法把消息放到消息队列MessageQueue中。而Looper则会不停地查看MessageQueue中是否有新消息msg,有新消息就会调用新消息msg.target.handleMessage()去处理消息,否则会一直阻塞。msg.target实际上是Handler对象。因此,Handler发送的消息,最终也是由Handler来处理。

问题

Q1: Handler是怎么在不同线程之间切换的?

  1. public final class Looper {


  2. ...... 

  3. public static void loop() { 

  4. final Looper me = myLooper(); 

  5. if (me == null) { 

  6. throw new RuntimeException("No Looper; Looper.prepare() wasn‘t called on this thread."); 



  7. final MessageQueue queue = me.mQueue; 

  8. ........ 

  9. for (;;) { 

  10. Message msg = queue.next(); // might block 

  11. if (msg == null) { 

  12. // No message indicates that the message queue is quitting. 

  13. return; 



  14. ...... 

  15. msg.target.dispatchMessage(msg); 

  16. ...... 

  17. msg.recycleUnchecked(); 







  1. public class Handler {


  2. /* 

  3. * Set this flag to true to detect anonymous, local or member classes 

  4. * that extend this Handler class and that are not static. These kind 

  5. * of classes can potentially create leaks. 

  6. */ 

  7. private static final boolean FIND_POTENTIAL_LEAKS = false; 

  8. private static final String TAG = "Handler"; 


  9. /** 

  10. * Callback interface you can use when instantiating a Handler to avoid 

  11. * having to implement your own subclass of Handler. 



  12. * @param msg A {@link android.os.Message Message} object 

  13. * @return True if no further handling is desired 

  14. */ 

  15. public interface Callback { 

  16. public boolean handleMessage(Message msg); 




  17. /** 

  18. * Subclasses must implement this to receive messages. 

  19. */ 

  20. public void handleMessage(Message msg) { 




  21. /** 

  22. * Handle system messages here. 

  23. */ 

  24. public void dispatchMessage(Message msg) { 

  25. if (msg.callback != null) { 

  26. handleCallback(msg); 

  27. } else { 

  28. if (mCallback != null) { 

  29. if (mCallback.handleMessage(msg)) { 

  30. return; 





  31. handleMessage(msg); 







首先在线程1新建一个handler,在线程2 新建一条消息msg,然后在线程2调用hander.sendMessage(msg),因为在handler的处理逻辑handleMessage()方法是放在线程1的,因此在线程2中调用了hander.sendMessage(msg),MessagQueue插入了这条消息,Looper发现有新消息,然后取出新消息,调用msg.target.dispatchMessage(msg),上面已经说到,target其实是hander,这样便成功地切换到线程1的handleMessage逻辑上来了。最常见的例子就是在Activity中声明一个Handler,然后异步线程去请求网络,再通过网络更新UI。可以参考这里

Q2: 上面的模型中,为何不直接使用Handler来循环消息?

这个问题仁者见仁,智者见智,这只是一种实现消息循环的方法之一,而不是唯一方法。不是说一定要用Looper。

Q3: 需要注意的点?

使用Looper前一定要调用Looper.prepare生成线程内(TheadLocal存储)的Looper实例,然后才能调用Looper.loop()实现消息循环。下面是一个非主线程中Looper和Handler演示例子,此时整个线程是不会自动停止的,会一直阻塞,直到调用了Looper.quit()方法才会停止。(下面代码仅仅是为了演示,没有做任何事)

  1. new Thread("example-1") {


  2. Handler handler = new Handler() { 

  3. @Override 

  4. public void handleMessage(Message msg) { 

  5. // 自己的处理逻辑 

  6. if (条件满足) { 

  7. Looper.quit() ; //退出消息循环,结束线程 





  8. } ; 

  9. @Override 

  10. public void run() { 

  11. Looper.prepare(); 

  12. // do something.... 

  13. Message msg = Message.obtain(); 

  14. msg.what = ... 

  15. msg.obj = ... 

  16. ....... 

  17. handler.sendMessage(msg); 

  18. Looper.loop(); 



  19. }.start() ; 

Q4: 为何ActivityThread中的Looper.loop()没有阻塞主线程?

。。。。。

参考

《Android开发艺术探索》

时间: 2024-09-29 19:42:46

Android Handler 消息循环机制的相关文章

Android HandlerThread 消息循环机制之源代码解析

关于 HandlerThread 这个类.可能有些人眼睛一瞟,手指放在键盘上,然后就是一阵狂敲.立即就能敲出一段段华丽的代码: HandlerThread handlerThread = new HandlerThread("handlerThread"); handlerThread.start(); Handler handler = new Handler(handlerThread.getLooper()){ public void handleMessage(Message

Android消息循环机制

转载请注明出处:http://blog.csdn.net/crazy1235/article/details/51707527 Android的消息循环机制主要先关的类有: Handler Looper Message MessageQueue ActivityThread 实际上 应用程序启动的时候,会创建一个UI线程,然后该线程关联一个消息队列,相关操作封装一个个消息放入队列中,主线程会不断循环从队列中取出消息进行分发处理. 为什么用Handler 大家都知道,Android规定[访问UI只

Android IntentService源码理解 及 HandlerThread构建消息循环机制分析

前言:前面写了Handler的源码理解,关于Handler在我们Android开发中是到处能见到的异步通信方式.那么,在Android原生里,有那些也有到了Handler机制的呢?有很多,比如我们今天所要理解分析的IntentService就使用到了Handler.接下来,我们来深入了解一下. HandlerThread: IntentService使用到了Handler+HandlerThread构建的带有消息循环的异步任务处理机制,我们先简单看一下HandlerThread是如何工作的吧.

Android Handler消息机制深入浅出

作为Android开发人员,Handler这个类应该是再熟悉不过了,因为几乎任何App的开发,都会使用到Handler这个类,有些同学可能就要说了,我完全可以使用AsyncTask代替它,这个确实是可以的,但是其实AsyncTask也是通过Handler实现的,具体的大家可以去看看源码就行了,Handler的主要功能就是实现子线程和主线程的通信,例如在子线程中执行一些耗时操作,操作完成之后通知主线程跟新UI(因为Android是不允许在子线程中跟新UI的). 下面就使用一个简单的例子开始这篇文章

安卓中的消息循环机制Handler及Looper详解

我们知道安卓中的UI线程不是线程安全的,我们不能在UI线程中进行耗时操作,通常我们的做法是开启一个子线程在子线程中处理耗时操作,但是安卓规定不允许在子线程中进行UI的更新操作,通常我们会通过Handler机制来完成该功能,即当子线程中耗时操作完成后,在子线程中通过Handler向主线程发送消息,在主线程中的Handler的handleMessage方法中处理接受到的消息.这就是安卓中的消息机制,安卓中的消息机制主要是指Handler的运行机制,但是Handler的运行需要底层的MessageQu

System、应用程序进程的Binder线程池和Handler消息循环

首先看一张Android系统启动流程图: 一个进程最重要的两项指标一个是启动了Binder线程池,也就是能够进程Binder进程间通信了.还有一个是启动了Handler消息循环,能够使用了消息循环机制. 1.那么systemserver进程是什么时候实现上面两个机制的呢?见代码: 启动了Binder线程池.是子线程池. public static final void zygoteInit(String[] argv) throws ZygoteInit.MethodAndArgsCaller

Android Handler 异步消息处理机制的妙用 创建强大的图片加载类

转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/38476887 ,本文出自[张鸿洋的博客] 最近创建了一个群,方便大家交流,群号:55032675 上一篇博客介绍了Android异步消息处理机制,如果你还不了解,可以看:Android 异步消息处理机制 让你深入理解 Looper.Handler.Message三者关系 .那篇博客的最后,提出可以把异步消息处理机制不仅仅是在MainActivity中更新UI,可以用到别的地方,

【Dart学习】-- Dart之消息循环机制[翻译]

概述 异步任务在Dart中随处可见,例如许多库的方法调用都会返回Future对象来实现异步处理,我们也可以注册Handler来响应一些事件,如:鼠标点击事件,I/O流结束和定时器到期. 这篇文章主要介绍了Dart中与异步任务相关的消息循环机制,阅读完这篇文章后相信你可写出更赞的异步执行代码.你也能学习到如何调度Future任务并且预测他们的执行顺序. 在阅读这篇文章之前,你最好先要了解一下基本的Future用法. 基本概念 如果你写过一些关于UI的代码,你就应该熟悉消息循环和消息队列.有了他们才

Win32消息循环机制等【转载】http://blog.csdn.net/u013777351/article/details/49522219

Dos的过程驱动与Windows的事件驱动 在讲本程序的消息循环之前,我想先谈一下Dos与Windows驱动机制的区别: DOS程序主要使用顺序的,过程驱动的程序设计方法.顺序的,过程驱动的程序有一个明显的开始,明显的过程及一个明显的结束,因此程序能直接控制程序事件或过程的顺序.虽然在顺序的过程驱动的程序中也有很多处理异常的方法,但这样的异常处理也仍然是顺序的,过程驱动的结构. 而Windows的驱动方式是事件驱动,就是不由事件的顺序来控制,而是由事件的发生来控制,所有的事件是无序的,所为一个程