Android的消息处理机制（图+源码分析）——Looper,Handler,Message

最新推荐文章于 2023-08-29 22:50:24 发布
最新推荐文章于 2023-08-29 22:50:24 发布
阅读量526 收藏 2
点赞数
分类专栏： android 文章标签： android callback java 任务 null thread

百度二面的时候，觉得自己源码分析太差，没有深入。面试官估计觉得我很不爽。恩，来吧。自己结合这篇文章，基本上把android消息机制给弄清楚了。

http://www.androidzz.com/2011/09/android-looper-handler-message/

作为一个大三的预备程序员，我学习android的一大乐趣是可以通过源码学习google大牛们的设计思想。android源码中包含了大量的设计模式，除此以外，android sdk还精心为我们设计了各种helper类，对于和我一样渴望水平得到进阶的人来说，都太值得一读了。这不，前几天为了了解android的消息处理机制，我看了Looper，Handler，Message这几个类的源码，结果又一次被googler的设计震撼了，特与大家分享。

android的消息处理有三个核心类：Looper,Handler和Message。其实还有一个Message Queue（消息队列），但是MQ被封装到Looper里面了，我们不会直接与MQ打交道，因此我没将其作为核心类。下面一一介绍：

线程的魔法师 Looper

Looper的字面意思是“循环者”，它被设计用来使一个普通线程变成Looper线程。所谓Looper线程就是循环工作的线程。在程序开发中（尤其是GUI开发中），我们经常会需要一个线程不断循环，一旦有新任务则执行，执行完继续等待下一个任务，这就是Looper线程。使用Looper类创建Looper线程很简单：

[java]  view plain copy
  1. public class LooperThread extends Thread {    
  2.     @Override    
  3.     public void run() {    
  4.         // 将当前线程初始化为Looper线程    
  5.         Looper.prepare();    
  6.     
  7.         // ...其他处理，如实例化handler    
  8.     
  9.         // 开始循环处理消息队列    
  10.         Looper.loop();    
  11.     }    
  12. }    

通过上面两行核心代码，你的线程就升级为Looper线程了！！！是不是很神奇？让我们放慢镜头，看看这两行代码各自做了什么。

1)Looper.prepare()


通过上图可以看到，现在你的线程中有一个Looper对象，它的内部维护了一个消息队列MQ。注意， 一个Thread只能有一个Looper对象，为什么呢？咱们来看源码。
[java]  view plain copy
  1. public class Looper {    
  2.     // 每个线程中的Looper对象其实是一个ThreadLocal，即线程本地存储(TLS)对象    
  3.     private static final ThreadLocal sThreadLocal = new ThreadLocal();    
  4.     // Looper内的消息队列    
  5.     final MessageQueue mQueue;    
  6.     // 当前线程    
  7.     Thread mThread;    
  8.     // 。。。其他属性    
  9.     
  10.     // 每个Looper对象中有它的消息队列，和它所属的线程    
  11.     private Looper() {    
  12.         mQueue = new MessageQueue();    
  13.         mRun = true;    
  14.         mThread = Thread.currentThread();    
  15.     }    
  16.     
  17.     // 我们调用该方法会在调用线程的TLS中创建Looper对象    
  18.     public static final void prepare() {    
  19.         if (sThreadLocal.get() != null) {    
  20.             // 试图在有Looper的线程中再次创建Looper将抛出异常    
  21.             throw new RuntimeException("Only one Looper may be created per thread");    
  22.         }    
  23.         sThreadLocal.set(new Looper());    
  24.     }    
  25.     // 其他方法    
  26. }    

通过源码，prepare()背后的工作方式一目了然，其核心就是将looper对象定义为ThreadLocal。如果你还不清楚什么是ThreadLocal，请参考 《理解ThreadLocal》。
2）Looper.loop()

调用loop方法后，Looper线程就开始真正工作了，它不断从自己的MQ中取出队头的消息(也叫任务)执行。其源码分析如下：
[java]  view plain copy
  1. public static final void loop() {    
  2.       Looper me = myLooper();  //得到当前线程Looper    
  3.       MessageQueue queue = me.mQueue;  //得到当前looper的MQ    
  4.     
  5.       // 这两行没看懂= = 不过不影响理解    
  6.       Binder.clearCallingIdentity();    
  7.       final long ident = Binder.clearCallingIdentity();    
  8.       // 开始循环    
  9.       while (true) {    
  10.           Message msg = queue.next(); // 取出message    
  11.           if (msg != null) {    
  12.               if (msg.target == null) {    
  13.                   // message没有target为结束信号，退出循环    
  14.                   return;    
  15.               }    
  16.               // 日志。。。    
  17.               if (me.mLogging!= null) me.mLogging.println(    
  18.                       ">>>>> Dispatching to " + msg.target + " "    
  19.                       + msg.callback + ": " + msg.what    
  20.                       );    
  21.               // 非常重要！将真正的处理工作交给message的target，即后面要讲的handler    
  22.               msg.target.dispatchMessage(msg);    
  23.               // 还是日志。。。    
  24.               if (me.mLogging!= null) me.mLogging.println(    
  25.                       "<<<<< Finished to    " + msg.target + " "    
  26.                       + msg.callback);    
  27.     
  28.               // 下面没看懂，同样不影响理解    
  29.               final long newIdent = Binder.clearCallingIdentity();    
  30.               if (ident != newIdent) {    
  31.                   Log.wtf("Looper", "Thread identity changed from 0x"    
  32.                           + Long.toHexString(ident) + " to 0x"    
  33.                           + Long.toHexString(newIdent) + " while dispatching to "    
  34.                           + msg.target.getClass().getName() + " "    
  35.                           + msg.callback + " what=" + msg.what);    
  36.               }    
  37.               // 回收message资源    
  38.               msg.recycle();    
  39.           }    
  40.       }    
  41.   }    

除了prepare()和loop()方法，Looper类还提供了一些有用的方法，比如

Looper.myLooper()得到当前线程looper对象：

[java]  view plain copy
  1. public static final Looper myLooper() {    
  2.     // 在任意线程调用Looper.myLooper()返回的都是那个线程的looper    
  3.     return (Looper)sThreadLocal.get();    
  4. }    

getThread()得到looper对象所属线程：
[java]  view plain copy
  1. public Thread getThread() {  
  2.        return mThread;  
  3.    }  

quit()方法结束looper循环：
[java]  view plain copy
  1. public void quit() {    
  2.     // 创建一个空的message，它的target为NULL，表示结束循环消息    
  3.     Message msg = Message.obtain();    
  4.     // 发出消息    
  5.     mQueue.enqueueMessage(msg, 0);    
  6. }    

到此为止，你应该对Looper有了基本的了解，总结几点：

1.每个线程有且最多只能有一个Looper对象，它是一个ThreadLocal

2.Looper内部有一个消息队列，loop()方法调用后线程开始不断从队列中取出消息执行

3.Looper使一个线程变成Looper线程。

那么，我们如何往MQ上添加消息呢？下面有请Handler！（掌声~~~）

异步处理大师 Handler

什么是handler？handler扮演了往MQ上添加消息和处理消息的角色（只处理由自己发出的消息），即通知MQ它要执行一个任务(sendMessage)，并在loop到自己的时候执行该任务(handleMessage)，整个过程是异步的。handler创建时会关联一个looper，默认的构造方法将关联当前线程的looper，不过这也是可以set的。默认的构造方法：

[java]  view plain copy
  1. public class handler {    
  2.     
  3.     final MessageQueue mQueue;  // 关联的MQ    
  4.     final Looper mLooper;  // 关联的looper    
  5.     final Callback mCallback;    
  6.     // 其他属性    
  7.     
  8.     public Handler() {    
  9.         // 没看懂，直接略过，，，    
  10.         if (FIND_POTENTIAL_LEAKS) {    
  11.             final Class<? extends Handler> klass = getClass();    
  12.             if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&    
  13.                     (klass.getModifiers() & Modifier.STATIC) == 0) {    
  14.                 Log.w(TAG, "The following Handler class should be static or leaks might occur: " +    
  15.                     klass.getCanonicalName());    
  16.             }    
  17.         }    
  18.         // 默认将关联当前线程的looper    
  19.         mLooper = Looper.myLooper();    
  20.         // looper不能为空，即该默认的构造方法只能在looper线程中使用    
  21.         if (mLooper == null) {    
  22.             throw new RuntimeException(    
  23.                 "Can't create handler inside thread that has not called Looper.prepare()");    
  24.         }    
  25.         // 重要！！！直接把关联looper的MQ作为自己的MQ，因此它的消息将发送到关联looper的MQ上    
  26.         mQueue = mLooper.mQueue;    
  27.         mCallback = null;    
  28.     }    
  29.     
  30.     // 其他方法    
  31. }    

下面我们就可以为之前的LooperThread类加入Handler：
[java]  view plain copy
  1. public class LooperThread extends Thread {    
  2.     private Handler handler1;    
  3.     private Handler handler2;    
  4.     
  5.     @Override    
  6.     public void run() {    
  7.         // 将当前线程初始化为Looper线程    
  8.         Looper.prepare();    
  9.     
  10.         // 实例化两个handler    
  11.         handler1 = new Handler();    
  12.         handler2 = new Handler();    
  13.     
  14.         // 开始循环处理消息队列    
  15.         Looper.loop();    
  16.     }    
  17. }    

加入handler后的效果如下图：

可以看到，一个线程可以有多个Handler，但是只能有一个Looper！

Handler发送消息

有了handler之后，我们就可以使用 post(Runnable), postAtTime(Runnable, long), postDelayed(Runnable, long), sendEmptyMessage(int), sendMessage(Message),sendMessageAtTime(Message, long)和 sendMessageDelayed(Message, long)这些方法向MQ上发送消息了。光看这些API你可能会觉得handler能发两种消息，一种是Runnable对象，一种是message对象，这是直观的理解，但其实post发出的Runnable对象最后都被封装成message对象了，见源码：

[java]  view plain copy
  1. // 此方法用于向关联的MQ上发送Runnable对象，它的run方法将在handler关联的looper线程中执行    
  2. public final boolean post(Runnable r)    
  3. {    
  4.    // 注意getPostMessage(r)将runnable封装成message    
  5.    return  sendMessageDelayed(getPostMessage(r), 0);    
  6. }    
  7.     
  8. private final Message getPostMessage(Runnable r) {    
  9.     Message m = Message.obtain();  //得到空的message    
  10.     m.callback = r;  //将runnable设为message的callback，    
  11.     return m;    
  12. }    
  13.     
  14. public boolean sendMessageAtTime(Message msg, long uptimeMillis)    
  15. {    
  16.     boolean sent = false;    
  17.     MessageQueue queue = mQueue;    
  18.     if (queue != null) {    
  19.         msg.target = this;  // message的target必须设为该handler！    
  20.         sent = queue.enqueueMessage(msg, uptimeMillis);    
  21.     }    
  22.     else {    
  23.         RuntimeException e = new RuntimeException(    
  24.             this + " sendMessageAtTime() called with no mQueue");    
  25.         Log.w("Looper", e.getMessage(), e);    
  26.     }    
  27.     return sent;    
  28. }    

其他方法就不罗列了，总之通过handler发出的message有如下特点：

1.message.target为该handler对象，这确保了looper执行到该message时能找到处理它的handler，即loop()方法中的关键代码

[java]  view plain copy
  1. msg.target.dispatchMessage(msg);   

2.post发出的message，其callback为Runnable对象

Handler处理消息

说完了消息的发送，再来看下handler如何处理消息。消息的处理是通过核心方法dispatchMessage(Messagemsg)与钩子方法handleMessage(Message msg)完成的，见源码

[java]  view plain copy
  1. // 处理消息，该方法由looper调用    
  2. public void dispatchMessage(Message msg) {    
  3.     if (msg.callback != null) {    
  4.         // 如果message设置了callback，即runnable消息，处理callback！    
  5.         handleCallback(msg);    
  6.     } else {    
  7.         // 如果handler本身设置了callback，则执行callback    
  8.         if (mCallback != null) {    
  9.              /* 这种方法允许让activity等来实现Handler.Callback接口，避免了自己编写handler重写handleMessage方法。见http://alex-yang-xiansoftware-com.iteye.com/blog/850865 */    
  10.             if (mCallback.handleMessage(msg)) {    
  11.                 return;    
  12.             }    
  13.         }    
  14.         // 如果message没有callback，则调用handler的钩子方法handleMessage    
  15.         handleMessage(msg);    
  16.     }    
  17. }    
  18.     
  19. // 处理runnable消息    
  20. private final void handleCallback(Message message) {    
  21.     message.callback.run();  //直接调用run方法！    
  22. }    
  23. // 由子类实现的钩子方法    
  24. public void handleMessage(Message msg) {    
  25. }    

可以看到，除了handleMessage(Message msg)和Runnable对象的run方法由开发者实现外（实现具体逻辑），handler的内部工作机制对开发者是透明的。这正是handler API设计的精妙之处！

Handler的用处

我在小标题中将handler描述为“异步处理大师”，这归功于Handler拥有下面两个重要的特点：

1.handler可以在任意线程发送消息，这些消息会被添加到关联的MQ上。


2.handler是在它关联的looper线程中处理消息的。

这就解决了android最经典的不能在其他非主线程中更新UI的问题。android的主线程也是一个looper线程(looper在android中运用很广)，我们在其中创建的handler默认将关联主线程MQ。因此，利用handler的一个solution就是在activity中创建handler并将其引用传递给worker thread，worker thread执行完任务后使用handler发送消息通知activity更新UI。(过程如图)

下面给出sample代码，仅供参考：

[java]  view plain copy
  1. public class TestDriverActivity extends Activity {    
  2.     private TextView textview;    
  3.     
  4.     @Override    
  5.     protected void onCreate(Bundle savedInstanceState) {    
  6.         super.onCreate(savedInstanceState);    
  7.         setContentView(R.layout.main);    
  8.         textview = (TextView) findViewById(R.id.textview);    
  9.         // 创建并启动工作线程    
  10.         Thread workerThread = new Thread(new SampleTask(new MyHandler()));    
  11.         workerThread.start();    
  12.     }    
  13.     
  14.     public void appendText(String msg) {    
  15.         textview.setText(textview.getText() + "\n" + msg);    
  16.     }    
  17.     
  18.     class MyHandler extends Handler {    
  19.         @Override    
  20.         public void handleMessage(Message msg) {    
  21.             String result = msg.getData().getString("message");    
  22.             // 更新UI    
  23.             appendText(result);    
  24.         }    
  25.     }    
  26. }    

[java]  view plain copy
  1. public class SampleTask implements Runnable {    
  2.     private static final String TAG = SampleTask.class.getSimpleName();    
  3.     Handler handler;    
  4.     
  5.     public SampleTask(Handler handler) {    
  6.         super();    
  7.         this.handler = handler;    
  8.     }    
  9.     
  10.     @Override    
  11.     public void run() {    
  12.         try {  // 模拟执行某项任务，下载等    
  13.             Thread.sleep(5000);    
  14.             // 任务完成后通知activity更新UI    
  15.             Message msg = prepareMessage("task completed!");    
  16.             // message将被添加到主线程的MQ中    
  17.             handler.sendMessage(msg);    
  18.         } catch (InterruptedException e) {    
  19.             Log.d(TAG, "interrupted!");    
  20.         }    
  21.     
  22.     }    
  23.     
  24.     private Message prepareMessage(String str) {    
  25.         Message result = handler.obtainMessage();    
  26.         Bundle data = new Bundle();    
  27.         data.putString("message", str);    
  28.         result.setData(data);    
  29.         return result;    
  30.     }    
  31.     
  32. }    

当然，handler能做的远远不仅如此，由于它能post Runnable对象，它还能与Looper配合实现经典的Pipeline Thread模式。请参考此文《Android Guts: Intro to Loopers and Handlers》

封装任务 Message

在整个消息处理机制中，message又叫task，封装了任务携带的信息和处理该任务的handler。message的用法比较简单，这里不做总结了。但是有这么几点需要注意（待补充）：

1.尽管Message有public的默认构造方法，但是你应该通过Message.obtain()来从消息池中获得空消息对象，以节省资源。

2.如果你的message只需要携带简单的int信息，请优先使用Message.arg1和Message.arg2来传递信息，这比用Bundle更省内存

3.擅用message.what来标识信息，以便用不同方式处理message。

furuidelei123
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Android学习笔记】初探Thread、Looper和handler之间的联系
b410604224的博客
07-14 2365
前几天写程序的时候碰到这么一个问题，当时想在子线程中Toast一段话，不废话上代码 new Thread(new Runnable() { @Override public void run() { new Handler(){ @Override ...
handler——消息队列模型
chuntiandejiaobu10的专栏
08-25 383
转自http://blog.csdn.net/fdaopeng/article/details/7863840 通过下图可以清晰显示出UI Thread, Worker Thread, Handler, Massage Queue, Looper之间的关系： 解释上图中的几个基本概念：   1.Message        消息对象，顾名思义就是记录消息信息的类。这个类
Thread, Looper, Handler
09-28 661
Runnable代码一个可执行的命令，通常用于在另一个线程执行一段代码。定义了一个方法run()，要在线程执行的代码就放在run()里面，当线程启动时，会调用run()，run()执行完毕之后，线程就结束了。Runnable时一个抽象类，可以从字面理解，凡是要在一个不同线程执行一段代码的类都需要继承Runnable。 像下面这样的用法实际上没有什么意义：new Runnable() { @
Android事件驱动Handler-Message-Looper解析
10-04 1132
前言 关于这方面的知识，网上已经有很多。为啥这里还要写呢？知其然，也要知其所以然，handler-message-looper的设计很巧妙，我们了解为啥要这么设计，对我们设计程序的时候也有裨益。这篇文章阐述怎么结合现象与原理分析事件驱动的本质，相信即使没看过相关知识的同学也能快速理解。 通过这篇文章你将知道： 1、如何进行线程切换 2、消息循环原理 3、子线程消息循环 4、链表实现栈和队列的 线程切换 Q1 为什么需要线程切换 1、多线程能够提高并发效率，多线程的引入势必会有线程切换 2、多线程同
安卓Android源码——HandlerLooper2.rar
10-11
在安卓开发中，`Handler`、`Looper`和`MessageQueue`是三个核心组件，它们共同构成了Android消息处理机制，用于实现线程间的通信。这个压缩包“安卓Android源码——HandlerLooper2.rar”可能包含了关于这些组件的...
安卓Android源码——HandlerLooper1.rar
10-11
在Android系统中，`Handler`、`Looper`和`MessageQueue`是三个核心组件，它们共同构成了Android消息处理机制，使得应用程序能够实现线程间的通信和异步任务执行。这个`HandlerLooper1.rar`文件可能包含了对这些概念...
安卓Android源码——HandlerMessage3.rar
10-11
这个压缩包"安卓Android源码——HandlerMessage3.rar"很可能包含了关于这三者如何协同工作的示例代码或者详细分析。现在，我们将深入探讨这些概念及其在Android系统中的作用。 `Handler` 是一个用于发送和处理消息...
安卓Android源码——HandlerMessage2.rar
10-11
本资源"安卓Android源码——HandlerMessage2.rar"可能包含了关于`Handler`和`Message`的深入实践和示例代码，下面我们将详细探讨这些核心组件。 `Handler` 是 Android 中用于在线程间传递消息的对象。它通常用于将...
Android中的Thread、Looper、Handler之间的关系
hello_tree的专栏
03-13 1219
其实非常简单，只要搞清楚Thread、Looper、Handler它们各自的作用就OK了。 Thread 这个大家都知道就是线程，线程中包括一个消息队列（Message Queue），一个循环处理消息队列中消息的工具（Looper）。Looper 这个可能有点陌生，就是Thread中的一个用来开启消息循环的工具，循环的取出Message Queue中的消息来让Thread执行。H
Handler，Loop，Message，MessageQueue，ThreadLocal关系详解
ibicf777的专栏
07-16 943
一直对handler机制一知半解，花了两天时间对handler从信息发送到接收，handler机制的整个过程就是handler发送信息给looper，looper在适当的时候通过handler的dispatchMessage方法回调给handler的过程，网上翻阅了一些资料结合源码重新滤了一遍，做下笔记，便于以后查阅，记忆是靠不住的。 Handler: android ui的改变是只能在主线程
多线程开发（二）－Thread、 Looper与Handler关系解密
江湖夜雨十年灯
02-10 944
第3节 Handler 多个线程之间除了有“执行的同步”关系，还有“数据的共享”关系，以及“功能的委托”关系。 例如之前提到的视频信息显示到列表上， 委托数据查询功能：主线程启动一个工作线程thread－查询视频信息；委托数据的界面更新功能：工作线程查询完成后，因为不能够修改界面元素，所以必须将结果通知到主线程，委托主线程将结果的结果显示到界面上。 为此，Android S
Message，Loop和Handler
GrassEva的博客
07-20 350
最近在弄Android，因为不允许在主线程中直接发送http请求获取图片，就搞起了Handler，然后看了网上和书上的各种原理，嗯。。。道理我都懂，但感觉用起来还是懵懵哒，就跑去翻了api文档，然后这篇文章算是总结 正文之前先写两点声明： 1. Runnable大家都知道是Thread实现的接口，但是和线程好像又不太一样，不知道要翻译成什么合适，就直接写Runnable了。 2. 因为是An...
Android中的Thread, Looper和Handler机制
lw6897的博客
03-14 1073
Thread，Looper和Handler的关系 Android是消息驱动型的系统，消息驱动机制的四要素是： 接收消息的“消息队列” 阻塞式地从消息队列中接收消息并进行处理的“线程” 可发送的“消息的格式” “消息发送函数” 与之对应，Android中的实现： 接收消息的“消息队列” ——【MessageQueue】 阻塞式地从消息队列中接收消息并进行处理的“线程” ——【Thread+L...
Thread+Looper+Handler原理及项目中后台线程的应用
u010852801的专栏
02-03 844
Handler在我刚做开发Andorid时就接触过，但是当时对其与Looper，MessageQueue，Thread的关系非常模糊。我觉得很多Android开发者都对Handler不是很清楚。由于最近的项目中使用Handler比较多，才对其原理进行了较深的研究。那么就写篇博客来总结一下吧，这样整体的思路才能更清楚，也能发现我不足的地方。        总体思路是：Looper源源不断的从Mes
Handler 的loop()方法详解
u011334510的博客
06-27 915
上篇说了loop()方法并不是handler用来取出消息的，那么这篇分析一下loop()的源码看下它到底是干嘛的。个人理解大概是用来等待接收消息的，他会使线程进入休眠状态，等待被唤醒。 这里关键的地方就是 MessageQueue的next方法。其中调用了nativePollOnce ，这个方法可以参看上篇提到的其他作者的native层源码分析（具体意思这个是Linux中的一种线程通讯机制，这个方法会让线程进入休眠状态） 还有Looper中的Observer。 looper中的Observer 是个抽
Handler与Looper
wfeii的博客
10-31 2469
文章目录概述Looperprepare方法loop方法quit方法主线程中的LooperHandlerHandler与Looper关联Hanlder处理消息Handler发送消息sendMessage方法post方法 概述 先看一个Android中的HandlerThread是如何使用Looper的。 public class HandlerThread extends Thread { ...
Android Looper Handler 机制浅析
最新发布
青山渺渺
08-29 3026
最近想写个播放器demo，里面要用到 Looper Handler，看了很多资料都没能理解透彻，于是决定自己看看相关的源码，并在此记录心得体会，希望能够帮助到有需要的人。本文会以猜想 + log验证的方式来学习 Android Looper Handler，对于一些复杂的代码会进行跳过，能够理解它们的设计原理即可。本文观点皆个人拙见，如有错误恳请赐教。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值