Message,MessageQueue,Looper,Handler详解+实例

最新推荐文章于 2025-10-22 19:51:14 发布
原创 最新推荐文章于 2025-10-22 19:51:14 发布 · 380 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#import #android #button #layout #class #数据结构

一、几个关键概念
　　1、MessageQueue：是一种数据结构，见名知义，就是一个消息队列，存放消息的地方。每一个线程最多只可以拥有一个MessageQueue数据结构。
　　创建一个线程的时候，并不会自动创建其MessageQueue。通常使用一个Looper对象对该线程的MessageQueue进行管理。主线程创建时，会创建一
　　个默认的Looper对象，而Looper对象的创建，将自动创建一个Message Queue。其他非主线程，不会自动创建Looper，要需要的时候，通过调
　　用prepare函数来实现。

　　2、Message：消息对象，Message Queue中的存放的对象。一个Message Queue中包含多个Message。
　　Message实例对象的取得，通常使用Message类里的静态方法obtain（），该方法有多个重载版本可供选择；它的创建并不一定是直接创建一个新的实例，
　　而是先从Message Pool（消息池）中看有没有可用的Message实例，存在则直接取出返回这个实例。如果Message Pool中没有可用的Message实例，
　　则才用给定的参数创建一个Message对象。调用removeMessages（）时，将Message从Message Queue中删除，同时放入到Message Pool中。除了上面这
　　种方式，也可以通过Handler对象的obtainMessage（）获取一个Message实例。

　　3、Looper：
　　是MessageQueue的管理者。每一个MessageQueue都不能脱离Looper而存在，Looper对象的创建是通过prepare函数来实现的。同时每一个Looper对象
　　和一个线程关联。通过调用Looper。myLooper（）可以获得当前线程的Looper对象
　　创建一个Looper对象时，会同时创建一个MessageQueue对象。除了主线程有默认的Looper，其他线程默认是没有MessageQueue对象的，所以，不能
　　接受Message。如需要接受，自己定义一个Looper对象（通过prepare函数），这样该线程就有了自己的Looper对象和MessageQueue数据结构了。
　　Looper从MessageQueue中取出Message然后，交由Handler的handleMessage进行处理。处理完成后，调用Message。recycle（）将其放入Message Pool中。

　　4、Handler：
　　消息的处理者，handler负责将需要传递的信息封装成Message，通过调用handler对象的obtainMessage（）来实现；
　　将消息传递给Looper，这是通过handler对象的sendMessage（）来实现的。继而由Looper将Message放入MessageQueue中。
　　当Looper对象看到MessageQueue中含有Message，就将其广播出去。该handler对象收到该消息后，调用相应的handler对象的handleMessage（）方法
　　对其进行处理。

　　二、线程之间的消息如何进行传递
　　1、主线程给自己发送Message
view source
print ?
01　　packagetest.message；
02　　importandroid.app.Activity；
03　　importandroid.os.Bundle；
04　　importandroid.os.Handler；
05　　importandroid.os.Looper；
06　　importandroid.os.Message；
07　　importandroid.view.View；
08　　importandroid.widget.Button；
09　　importandroid.widget.TextView；
10　　publicclassMainActivity extendsActivity {
11　　privateButton btnTest；
12　　privateTextView textView；
13　　privateHandler handler；
14　　@Override
15　　publicvoidonCreate（Bundle savedInstanceState） {
16　　super.onCreate（savedInstanceState）；
17　　setContentView（R.layout.main）；
18　　btnTest = （Button）this.findViewById（R.id.btn_01）；
19　　textView = （TextView）this.findViewById（R.id.view_01）；
20　　btnTest.setOnClickListener（newView.OnClickListener（） {
21　　@Override
22　　publicvoidonClick（View arg0） {
23　　Looper looper = Looper.getMainLooper（）；//主线程的Looper对象
24　　//这里以主线程的Looper对象创建了handler，
25　　//所以，这个handler发送的Message会被传递给主线程的MessageQueue.
26　　handler = newMyHandler（looper）；
27　　handler.removeMessages（0）；
28　　//构建Message对象
29　　//第一个参数：是自己指定的message代号，方便在handler选择性地接收
30　　//第二三个参数没有什么意义
31　　//第四个参数需要封装的对象
32　　Message msg = handler.obtainMessage（1，1，1，"主线程发消息了"）；
33　　handler.sendMessage（msg）； //发送消息
34　　}
35　　}）；
36　　}
37　　classMyHandlerextendsHandler{
38　　publicMyHandler（Looper looper）{
39　　super（looper）；
40　　}
41　　publicvoidhandleMessage（Message msg）{
42　　super.handleMessage（msg）；
43　　textView.setText（"我是主线程的Handler，收到了消息："+（String）msg.obj）；
44　　}
45　　}
46　　}
　　2、其他线程给主线程发送Message
view source
print ?
01　　packagetest.message；
02　　importandroid.app.Activity；
03　　importandroid.os.Bundle；
04　　importandroid.os.Handler；
05　　importandroid.os.Looper；
06　　importandroid.os.Message；
07　　importandroid.view.View；
08　　importandroid.widget.Button；
09　　importandroid.widget.TextView；
10　　publicclassMainActivity extendsActivity {
11　　privateButton btnTest；
12　　privateTextView textView；
13　　privateHandler handler；
14　　@Override
15　　publicvoidonCreate（Bundle savedInstanceState） {
16　　super.onCreate（savedInstanceState）；
17　　setContentView（R.layout.main）；
18　　btnTest = （Button）this.findViewById（R.id.btn_01）；
19　　textView = （TextView）this.findViewById（R.id.view_01）；
20　　btnTest.setOnClickListener（newView.OnClickListener（） {
21　　@Override
22　　publicvoidonClick（View arg0） {
23　　//可以看出这里启动了一个线程来操作消息的封装和发送的工作
24　　//这样原来主线程的发送就变成了其他线程的发送，简单吧？呵呵
25　　newMyThread（）.start（）；
26　　}
27　　}）；
28　　}
29　　classMyHandlerextendsHandler{
30　　publicMyHandler（Looper looper）{
31　　super（looper）；
32　　}
33　　publicvoidhandleMessage（Message msg）{
34　　super.handleMessage（msg）；
35　　textView.setText（"我是主线程的Handler，收到了消息："+（String）msg.obj）；
36　　}
37　　}
38　　//加了一个线程类
39　　classMyThreadextendsThread{
40　　publicvoidrun（）{
41　　Looper looper = Looper.getMainLooper（）；//主线程的Looper对象
42　　//这里以主线程的Looper对象创建了handler，
43　　//所以，这个handler发送的Message会被传递给主线程的MessageQueue.
44　　handler = newMyHandler（looper）；
45　　//构建Message对象
46　　//第一个参数：是自己指定的message代号，方便在handler选择性地接收
47　　//第二三个参数没有什么意义
48　　//第四个参数需要封装的对象
49　　Message msg = handler.obtainMessage（1，1，1，"其他线程发消息了"）；
50　　handler.sendMessage（msg）； //发送消息
51　　}
52　　}
53　　}3、主线程给其他线程发送Message
　　package test.message；
　　import android.app.Activity；
　　import android.os.Bundle；
　　import android.os.Handler；
　　import android.os.Looper；
　　import android.os.Message；
　　import android.view.View；
　　import android.widget.Button；
　　import android.widget.TextView；
　　public class MainActivity extends Activity {
　　private Button btnTest；
　　private TextView textView；
　　private Handler handler；
　　@Override
　　public void onCreate（Bundle savedInstanceState） {
　　super.onCreate（savedInstanceState）；
　　setContentView（R.layout.main）；
　　btnTest = （Button）this.findViewById（R.id.btn_01）；
　　textView = （TextView）this.findViewById（R.id.view_01）；
　　//启动线程
　　new MyThread（）.start（）；
　　btnTest.setOnClickListener（new View.OnClickListener（） {
　　@Override
　　public void onClick（View arg0） {
　　//这里handler的实例化在线程中
　　//线程启动的时候就已经实例化了
　　Message msg = handler.obtainMessage（1，1，1，"主线程发送的消息"）；
　　handler.sendMessage（msg）；
　　}
　　}）；
　　}

　　class MyHandler extends Handler{
　　public MyHandler（Looper looper）{
　　super（looper）；
　　}
　　public void handleMessage（Message msg）{
　　super.handleMessage（msg）；
　　textView.setText（"我是主线程的Handler，收到了消息："+（String）msg.obj）；
　　}
　　}

　　class MyThread extends Thread{
　　public void run（）{
　　Looper.prepare（）； //创建该线程的Looper对象，用于接收消息
　　//注意了：这里的handler是定义在主线程中的哦，呵呵，
　　//前面看到直接使用了handler对象，是不是在找，在什么地方实例化的呢？
　　//现在看到了吧？？？呵呵，开始的时候实例化不了，因为该线程的Looper对象
　　//还不存在呢.现在可以实例化了
　　//这里Looper.myLooper（）获得的就是该线程的Looper对象了
　　handler = new ThreadHandler（Looper.myLooper（））；
　　//这个方法，有疑惑吗？
　　//其实就是一个循环，循环从MessageQueue中取消息.
　　//不经常去看看，你怎么知道你有新消息呢？？？
　　Looper.loop（）；
　　}

　　//定义线程类中的消息处理类
　　class ThreadHandler extends Handler{
　　public ThreadHandler（Looper looper）{
　　super（looper）；
　　}

　　public void handleMessage（Message msg）{
　　//这里对该线程中的MessageQueue中的Message进行处理
　　//这里我们再返回给主线程一个消息
　　handler = new MyHandler（Looper.getMainLooper（））；
　　Message msg2 = handler.obtainMessage（1，1，1，"子线程收到："+（String）msg.obj）；
　　handler.sendMessage（msg2）；
　　}
　　}
　　}
　　}
[/java]
　　4、其他线程给自己发送Message
　　package test.message；
　　import android.app.Activity；
　　import android.os.Bundle；
　　import android.os.Handler；
　　import android.os.Looper；
　　import android.os.Message；
　　import android.view.View；
　　import android.widget.Button；
　　import android.widget.TextView；
　　public class MainActivity extends Activity {
　　private Button btnTest；
　　private TextView textView；
　　private Handler handler；
　　@Override
　　public void onCreate（Bundle savedInstanceState） {
　　super.onCreate（savedInstanceState）；
　　setContentView（R.layout.main）；
　　btnTest = （Button）this.findViewById（R.id.btn_01）；
　　textView = （TextView）this.findViewById（R.id.view_01）；
　　btnTest.setOnClickListener（new View.OnClickListener（） {
　　@Override
　　public void onClick（View arg0） {
　　//启动线程
　　new MyThread（）.start（）；
　　}
　　}）；
　　}
　　class MyHandler extends Handler{
　　public MyHandler（Looper looper）{
　　super（looper）；
　　}
　　public void handleMessage（Message msg）{
　　super.handleMessage（msg）；
　　textView.setText（（String）msg.obj）；
　　}
　　}
　　class MyThread extends Thread{
　　public void run（）{
　　Looper.prepare（）； //创建该线程的Looper对象
　　//这里Looper.myLooper（）获得的就是该线程的Looper对象了
　　handler = new ThreadHandler（Looper.myLooper（））；
　　Message msg = handler.obtainMessage（1，1，1，"我自己"）；
　　handler.sendMessage（msg）；
　　Looper.loop（）；
　　}
　　//定义线程类中的消息处理类
　　class ThreadHandler extends Handler{
　　public ThreadHandler（Looper looper）{
　　super（looper）；
　　}
　　public void handleMessage（Message msg）{
　　//这里对该线程中的MessageQueue中的Message进行处理
　　//这里我们再返回给主线程一个消息
　　//加入判断看看是不是该线程自己发的信息
　　if（msg.what == 1 && msg.obj.equals（"我自己"））{
　　handler = new MyHandler（Looper.getMainLooper（））；
　　Message msg2 = handler.obtainMessage（1，1，1，"禀告主线程：我收到了自己发给自己的Message"）；
　　handler.sendMessage（msg2）；
　　}
　　}
　　}
　　}
　　}
[/java]
　　附注：
　　上面四个例子的布局文件是同一个文件main.xml
view source
print ?
01　　<？xml version="1.0"encoding="utf-8"？>
02　　<LinearLayout xmlns：android="http：//schemas.android.com/apk/res/android"
03　　android：orientation="vertical"
04　　android：layout_width="fill_parent"
05　　android：layout_height="fill_parent"
06　　>
07　　<TextView android：id="@+id/view_01"
08　　android：layout_width="fill_parent"
09　　android：layout_height="wrap_content"
10　　android：text="@string/hello"
11　　/>
12　　<Button android：id="@+id/btn_01"
13　　android：layout_width="fill_parent"
14　　android：layout_height="wrap_content"
15　　android：text="测试消息"/>
16　　</LinearLayout>
Android之Handler、Message、MessageQueue、Looper详解
是阿超
12-06 3336
Android之Handler、Message、MessageQueue、Looper详解
Android Handler机制-Looper、Handler、MessageQueue、Message的关系
鸿蒙开发知识记录
06-19 862
一、概述 Handler是Android中处理异步消息的机制。Looper、Handler、MessageQueue、Message概括来说就是：Looper负责的就是创建一个MessageQueue，然后进入一个无限循环体不断从该MessageQueue中读取消息Message，然后回调相应的消息处理函数，而消息的创建者就是一个或多个Handler，执行完成一个消息后则继续循环。 二、MessageQueue详解 消息队列MessageQueue就是存放消息的队列。那队列中存储的消息是什么呢？.
Handler、MessageQueue、Looper底层原理梳理(详解)
appron的博客
08-26 1061
本文深入分析了Android消息处理机制的核心组件：Handler、Looper、Message和MessageQueue的工作原理及相互关系。详细列举了安卓源码，对理解安卓的通信机制有重要意义。解释的非常详细，非常适合刚入门的小伙伴。
请解释下在单线程模型中Message、Handler、Message Queue、Looper之间的关系。
Skypine_Lee的专栏
06-26 2368
http://hi.baidu.com/957898734/item/c4200998f190e48258146184 1、 请解释下在单线程模型中Message、Handler、Message Queue、Looper之间的关系。 答：简单的说，Handler获取当前线程中的looper对象，looper用来从存放Message的MessageQueue中取出Message，
《MessageQueue 队列机制：Handler 消息调度的底层数据结构解析》
最新发布
tghhjkjsj的博客
10-22 638
MessageQueue 是 Handler 机制中的关键队列，负责存储和调度消息对象（Message）。每个 Handler 实例关联一个独立的 MessageQueue，用于在目标线程中管理消息的生命周期。消息队列的核心作用是确保消息按顺序执行，支持延迟消息处理（如定时任务）。队列机制基于生产者-消费者模型：生产者线程（如后台线程）通过 Handler 发送消息到队列，消费者线程（如主线程）从队列中取出并处理消息。
消息队列（Message Queues）有关的数据结构 ipc_perm msgbuf msg msqid_ds
03-17 2035
在介绍消息队列的使用前，让我们先熟悉一下在后面会碰到的几个和消息队列有关的 数据结构： 1．ipc_perm 系统使用ipc_perm 结构来保存每个IPC 对象权限信息。在Linux 的库文件linux/ipc.h 中，它是这样定义的： struct ipc_perm { key_t key; ushort uid; /* owner euid a
Handler,Looper,MessageQueue,Message解析
蔷薇_wendy的博客
08-31 594
Handler：用于线程间的通信,handler会在实例化它的Thread上注册，它提供了一个通道将数据发送给它注册的Thread（比如，你在某个activity中onCreate方法中实例化了一个handler,这个handler将用于向主线程中传递数据）通过handler的方法将Message或者Runnable对象发送到handler所在线程的Looper中的MessageQueue中，通过H
Message,MessageQueue,Looper,Handler详解[归类].pdf
10-11
MessageQueue与Looper紧密配合，当MessageQueue中有新消息时，Looper会取出并分发给对应的Handler进行处理。主线程默认已经创建了MessageQueue和Looper，而在其他非主线程中，开发者需要手动调用`Looper.prepare()`...
Message,MessageQueue,Looper,Handler详解
02-22
### Message,MessageQueue,Looper,Handler详解 #### 一、几个关键概念 ##### 1、MessageQueue：消息队列 MessageQueue是一种数据结构，顾名思义，它充当了一个消息队列的角色，用来存放各种消息对象。每一个线程...
Android 消息传递机制 - Looper/Handler/MessageQueue/Message 详解
码农的世界
01-22 1246
目录 总览 Message Obtain - 获取对象 Recycle Asynchronous - 异步 MessageQueue enqueueMessage函数详解 next函数详解 barrier详解 postSyncBarrier函数解读 removeSyncBarrier函数解读 IdleHandler解读 FileDescriptor介绍 Handler ...
进程间通信之消息队列 ( message queue ）——完整代码
01-24
进程间通信之消息队列 ( message queue ） 消息队列是消息的链表,具有特定的格式,并由消息队列标识符标识. 七种进程间通信方式： 一.无名管道（ pipe ） 二.有名管道（ fifo ） 三.共享内存 ( shared memory ) 四.信号 ( sinal ) 五.消息队列 ( message queue ） 六.信号量 ( semophore ) 七.套接字 ( socket ) 以上七种进程间通信的完整代码，皆可以在我的资源列表中获取下载： 资源列表：http://download.youkuaiyun.com/user/qiulanzhu
Android7.0 MessageQueue详解
01-05
Android中的消息处理机制大量依赖于Handler。每个Handler都有对应的Looper，用于不断地从对应的MessageQueue中取出消息处理。 一直以来，觉得MessageQueue应该是Java层的抽象，然而事实上MessageQueue的主要部分在Native层中。 自己对MessageQueue在Native层的工作不太熟悉，借此机会分析一下。 一、MessageQueue的创建 当需要使用Looper时，我们会调用Looper的prepare函数： public static void prepare() { prepare(true); } private
Android消息机制好帮手—Looper、MessageQueue、Handler、Message
shu_lance的博客
08-20 292
基础常识 1、 Android 中只有主线程才能更新UI，Android机制的规定，主要是为了保证UI绘制的流畅，防止并发出问题； 2、 Android 中主线程不允许阻塞超过5s，否则可能会ANR； 3、 Handler机制的核心就是实现线程之间通信； 如何涉及一套线程间通信的机制？ Q1：如何涉及线程间通信？ A1：利用面向对象这个概念，创建一个对象obj，然后在子线程中给obj的一个属性赋值，然后在主线程中，操作obj对象，就可以拿到子线程赋值的结果，完成一次线程通信； Q2：主线程什么时候去操
深入理解Handler、Message、MessageQueue、Looper
宵待草夜情
04-16 7138
本文是从源码的角度对andorid异步消息处理机制的梳理，那么在文章开始阶段，先简单介绍，异步消息处理机制中各部件的作用以及处理处理机制的概述1、Handler、Message、MessageQueue、Looper功能简述Handler负责消息处理，包括消息的发送和消息的接收，内部跟Looper有关联。Message是消息的载体，里面封装了消息的具体内容MessageQueue是消息列表，存在着...
Android异步消息处理机制，深入理解Handler（MessageQueue、Message、Looper）
vanpersie_9987的博客
02-27 580
研读Android源码就会发现，Handler几乎无处不在，之所以是这样，是因为Android应用程序是使用消息来驱动的，Android系统从某种意义上讲也是一个通过消息驱动的系统，本文将通过图文并茂+源码解读+举例理解的方式，来向你详解Android中的异步消息处理机制——Handler，以及MessageQueue、Message、Looper的关系。
linux消息队列的数据结构是什么,消息队列（MessageQueues）有关的数据结构ipc_permmsgbufmsgmsqid_ds...
weixin_29671137的博客
05-12 386
转自https://blog.youkuaiyun.com/lishaman/article/details/6671873/数据结构：1．ipc_perm系统使用ipc_perm 结构来保存每个IPC对象权限信息。在Linux 的库文件linux/ipc.h中，它是这样定义的：struct ipc_perm{key_t key;ushort uid;ushort gid;ushort cuid;ushort...
深入理解MessageQueue
热门推荐
栀夏暖阳的博客
05-05 1万+
Android 中有两个非常重要的知识点，分别是Binder机制和Handler机制。前者用于跨进程通讯，并且通过 ServiceManager 给上层应用提供了大量的服务，而后者用于进程内部通讯，以消息队列的形式驱动应用的运行。之前的文章已经多次分析了Binder相关的内容，复杂程度远高于Handler，之后还会继续分析Binder。说到Handler，做安卓开发的一定都不会陌生，一般用于切换线
Message Queue 简介
01-21 5542
Queue（队列），这个词在《数据结构》的课程中出现过，即先进先出的一中数据结构，形象例子就是简单的铁路隧道和排队机；和Queue对应的就是stack（栈），Stack是一种先进后出的数据结构；如果看中文书，还有一个名词用于混，就是heap（堆），这个也很形象，进出是没有顺序的，就像煤堆。在计算机科学中，Message Queue(MQ)，就是按顺序传递消息的一种技术。MQ一般都做为企业级
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值