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

最新推荐文章于 2021-07-13 21:52:27 发布
最新推荐文章于 2021-07-13 21:52:27 发布
阅读量642 收藏 1
点赞数
分类专栏： Android

一、几个关键概念
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

01<b>packagetest.message;
02 
03import android.app.Activity;
04import android.os.Bundle;
05import android.os.Handler;
06import android.os.Looper;
07import android.os.Message;
08import android.view.View;
09import android.widget.Button;
10import android.widget.TextView;
11 
12public classMainActivity extends Activity {
13     
14    privateButton btnTest;
15    privateTextView textView;
16     
17    privateHandler handler;
18     
19    @Override
20    publicvoid onCreate(Bundle savedInstanceState) {
21        super.onCreate(savedInstanceState);
22        setContentView(R.layout.main);
23         
24        btnTest = (Button)this.findViewById(R.id.btn_01);
25        textView = (TextView)this.findViewById(R.id.view_01);
26         
27        btnTest.setOnClickListener(newView.OnClickListener() {
28             
29            @Override
30            publicvoid onClick(View arg0) {
31                 
32                Looper looper = Looper.getMainLooper();//主线程的Looper对象
33                //这里以主线程的Looper对象创建了handler，
34                //所以，这个handler发送的Message会被传递给主线程的MessageQueue。
35                handler =new MyHandler(looper);
36                handler.removeMessages(0);
37                //构建Message对象
38                //第一个参数：是自己指定的message代号，方便在handler选择性地接收
39                //第二三个参数没有什么意义
40                //第四个参数需要封装的对象
41                Message msg = handler.obtainMessage(1,1,1,"主线程发消息了");
42                 
43                handler.sendMessage(msg);//发送消息
44                 
45            }
46        });
47    }
48     
49    classMyHandler extends Handler{
50         
51        publicMyHandler(Looper looper){
52            super(looper);
53        }
54         
55        publicvoid handleMessage(Message msg){
56            super.handleMessage(msg);
57            textView.setText("我是主线程的Handler，收到了消息："+(String)msg.obj);
58        }
59    }
60}</b>

2、其他线程给主线程发送Message

01<b>packagetest.message;
02 
03import android.app.Activity;
04import android.os.Bundle;
05import android.os.Handler;
06import android.os.Looper;
07import android.os.Message;
08import android.view.View;
09import android.widget.Button;
10import android.widget.TextView;
11 
12public classMainActivity extends Activity {
13     
14    privateButton btnTest;
15    privateTextView textView;
16     
17    privateHandler handler;
18     
19    @Override
20    publicvoid onCreate(Bundle savedInstanceState) {
21        super.onCreate(savedInstanceState);
22        setContentView(R.layout.main);
23         
24        btnTest = (Button)this.findViewById(R.id.btn_01);
25        textView = (TextView)this.findViewById(R.id.view_01);
26         
27        btnTest.setOnClickListener(newView.OnClickListener() {
28             
29            @Override
30            publicvoid onClick(View arg0) {
31                 
32                //可以看出这里启动了一个线程来操作消息的封装和发送的工作
33                //这样原来主线程的发送就变成了其他线程的发送，简单吧？呵呵
34                newMyThread().start();   
35            }
36        });
37    }
38     
39    classMyHandler extends Handler{
40         
41        publicMyHandler(Looper looper){
42            super(looper);
43        }
44         
45        publicvoid handleMessage(Message msg){
46            super.handleMessage(msg);
47            textView.setText("我是主线程的Handler，收到了消息："+(String)msg.obj);
48        }
49    }
50     
51    //加了一个线程类
52    classMyThread extends Thread{
53         
54        publicvoid run(){
55            Looper looper = Looper.getMainLooper();//主线程的Looper对象
56            //这里以主线程的Looper对象创建了handler，
57            //所以，这个handler发送的Message会被传递给主线程的MessageQueue。
58            handler =new MyHandler(looper);
59 
60            //构建Message对象
61            //第一个参数：是自己指定的message代号，方便在handler选择性地接收
62            //第二三个参数没有什么意义
63            //第四个参数需要封装的对象
64            Message msg = handler.obtainMessage(1,1,1,"其他线程发消息了");
65             
66            handler.sendMessage(msg);//发送消息           
67        }
68    }
69}<span style="font-family:Arial;"><span style="white-space:normal;"> </span></span></b>

3、主线程给其他线程发送Message

01<b>packagetest.message;
02 
03import android.app.Activity;
04import android.os.Bundle;
05import android.os.Handler;
06import android.os.Looper;
07import android.os.Message;
08import android.view.View;
09import android.widget.Button;
10import android.widget.TextView;
11 
12public classMainActivity extends Activity {
13     
14    privateButton btnTest;
15    privateTextView textView;
16     
17    privateHandler handler;
18     
19    @Override
20    publicvoid onCreate(Bundle savedInstanceState) {
21        super.onCreate(savedInstanceState);
22        setContentView(R.layout.main);
23         
24        btnTest = (Button)this.findViewById(R.id.btn_01);
25        textView = (TextView)this.findViewById(R.id.view_01);
26         
27         
28        //启动线程
29        newMyThread().start();   
30         
31        btnTest.setOnClickListener(newView.OnClickListener() {
32             
33            @Override
34            publicvoid onClick(View arg0) {
35                //这里handler的实例化在线程中
36                //线程启动的时候就已经实例化了
37                Message msg = handler.obtainMessage(1,1,1,"主线程发送的消息");
38                handler.sendMessage(msg);
39            }
40        });
41    }
42     
43    classMyHandler extends Handler{
44         
45        publicMyHandler(Looper looper){
46            super(looper);
47        }
48         
49        publicvoid handleMessage(Message msg){
50            super.handleMessage(msg);
51            textView.setText("我是主线程的Handler，收到了消息："+(String)msg.obj);
52        }
53    }
54     
55    classMyThread extends Thread{
56         
57        publicvoid run(){
58            Looper.prepare();//创建该线程的Looper对象，用于接收消息
59             
60            //注意了：这里的handler是定义在主线程中的哦，呵呵，
61            //前面看到直接使用了handler对象，是不是在找，在什么地方实例化的呢？
62            //现在看到了吧？？？呵呵，开始的时候实例化不了，因为该线程的Looper对象
63            //还不存在呢。现在可以实例化了
64            //这里Looper.myLooper()获得的就是该线程的Looper对象了
65            handler =new ThreadHandler(Looper.myLooper());
66             
67            //这个方法，有疑惑吗？
68            //其实就是一个循环，循环从MessageQueue中取消息。
69            //不经常去看看，你怎么知道你有新消息呢？？？
70            Looper.loop();
71 
72        }
73         
74        //定义线程类中的消息处理类
75        classThreadHandler extends Handler{
76             
77            publicThreadHandler(Looper looper){
78                super(looper);
79            }
80             
81            publicvoid handleMessage(Message msg){
82                //这里对该线程中的MessageQueue中的Message进行处理
83                //这里我们再返回给主线程一个消息
84                handler =new MyHandler(Looper.getMainLooper());
85                 
86                Message msg2 = handler.obtainMessage(1,1,1,"子线程收到:"+(String)msg.obj);
87                 
88                handler.sendMessage(msg2);
89            }
90        }
91    }
92}</b>

4、其他线程给自己发送Message 

01<b>packagetest.message;
02 
03import android.app.Activity;
04import android.os.Bundle;
05import android.os.Handler;
06import android.os.Looper;
07import android.os.Message;
08import android.view.View;
09import android.widget.Button;
10import android.widget.TextView;
11 
12public classMainActivity extends Activity {
13     
14    privateButton btnTest;
15    privateTextView textView;
16     
17    privateHandler handler;
18     
19    @Override
20    publicvoid onCreate(Bundle savedInstanceState) {
21        super.onCreate(savedInstanceState);
22        setContentView(R.layout.main);
23         
24        btnTest = (Button)this.findViewById(R.id.btn_01);
25        textView = (TextView)this.findViewById(R.id.view_01);
26         
27         
28        btnTest.setOnClickListener(newView.OnClickListener() {
29             
30            @Override
31            publicvoid onClick(View arg0) {
32                //启动线程
33                newMyThread().start();   
34            }
35        });
36    }
37     
38    classMyHandler extends Handler{
39         
40        publicMyHandler(Looper looper){
41            super(looper);
42        }
43         
44        publicvoid handleMessage(Message msg){
45            super.handleMessage(msg);
46            textView.setText((String)msg.obj);
47        }
48    }   
49     
50    classMyThread extends Thread{
51         
52        publicvoid run(){
53            Looper.prepare();//创建该线程的Looper对象
54            //这里Looper.myLooper()获得的就是该线程的Looper对象了
55            handler =new ThreadHandler(Looper.myLooper());
56            Message msg = handler.obtainMessage(1,1,1,"我自己");
57            handler.sendMessage(msg);
58             
59            Looper.loop();
60 
61        }
62         
63        //定义线程类中的消息处理类
64        classThreadHandler extends Handler{
65             
66            publicThreadHandler(Looper looper){
67                super(looper);
68            }
69             
70            publicvoid handleMessage(Message msg){
71                //这里对该线程中的MessageQueue中的Message进行处理
72                //这里我们再返回给主线程一个消息
73                //加入判断看看是不是该线程自己发的信息
74                if(msg.what ==1 && msg.obj.equals("我自己")){
75                     
76                    handler =new MyHandler(Looper.getMainLooper());
77                     
78                    Message msg2 = handler.obtainMessage(1,1,1,"禀告主线程:我收到了自己发给自己的Message");
79                     
80                    handler.sendMessage(msg2);               
81                }
82 
83            }
84        }
85    }
86}</b>

xiaodanpeng
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Message,MessageQueue,Looper,Handler详解
02-22
### Message,MessageQueue,Looper,Handler详解 #### 一、几个关键概念 ##### 1、MessageQueue：消息队列 MessageQueue是一种数据结构，顾名思义，它充当了一个消息队列的角色，用来存放各种消息对象。每一个线程...
Android 之 Looper、MessageQueue、Handler 与消息循环
11-22
### Android之Looper、MessageQueue、Handler与消息循环详解 #### 一、概述 在Android开发过程中，消息处理机制是至关重要的部分，它涉及到应用程序如何管理、传递和响应各种事件。本篇文章将深入探讨Android中...
Android 消息机制Handler之MessageQueue
xy1131975903的专栏
10-10 182
MessageQueue: 只能通过 Looper.getQueue方法获取，其构造函数是包私有。 MessageQueue中主要了解入队，出队，以及idleHandler。 入队： boolean enqueueMessage(Message msg, long when) { if (msg.target == null) { throw ...
Android 消息机制之深入学习MessageQueue
阿有的博客
05-26 2221
一，简述 MessageQueue在Android中指消息队列，顾名思义就是存放消息的消息池，但是它的内部实现并不是队列而是一个单链表，可能是单链表的删除和插入比较有优势吧。MessageQueue的内部对消息的主要操作就是插入，读取删除，不具备处理消息的能力。 二，源码分析 1，重要属性信息介绍 // True if the message queue can be q...
回头看Android之handler,message,messagequeue,looper
HelloWorld
06-12 318
handler是什么 handler实质上是Android引入的一种让开发者参与处理线程中消息循环的机制。这句话可以点出了精髓。来，大家跟我一起来断句读一下。重点在后半句，一种让开发者参与/处理/线程中/消息循环/的机制。实际上这句话点出了这个三个关键字。 1、处理 2、线程 3、消息循环 好了，大家先记着这个，我们接着继续解读handler。来看大佬手绘的一张图。 同样的，大家先记着这
Android MessageQueue 底层实现（java）
朝花夕拾
06-16 608
文章目录如何使用消息队列消息队列的工作原理2.1 首先是创建 Looper2.2 创建 Handler2.3 Looper 进入消息循环2.4 Handler 发送消息2.5 Handler 处理消息 如何使用消息队列 使用消息队列需要准备如下三个类： 类名 功能 Handler 负责发送和接收消息 Looper 负责从消息队列取消息，然后派发消息 Message 用于承载消息 要理解消息队列的底层工作原理，首先要知道怎么在程序中使用消息队列。由于消息队列是 Android 系统
Message,MessageQueue,Looper,Handler详解[归类].pdf
10-11
在Android系统中，Message, MessageQueue, Looper, 和 Handler共同构成了一个跨线程通信机制，使得UI线程和其他工作线程之间能安全地交换数据和执行任务，这对于实现复杂的异步操作和保持用户界面的响应性至关重要。...
Android7.0 MessageQueue详解
09-01
在Android 7.0中，MessageQueue主要用于组织和管理待处理的消息，这些消息通常由Handler对象发送，并在适当的时机由Looper处理。理解MessageQueue的工作原理对于优化应用程序性能和解决多线程同步问题至关重要。 1....
Android消息处理机制Looper和Handler详解
09-04
Android应用的运行基于消息驱动模型，这一模型的核心在于Looper、Handler和MessageQueue的协同工作。下面我们将深入理解这三个组件的作用及其交互。 1. **Message（消息）**： - Message是应用程序中传递信息的...
活用Android的Message Queue
11-25
1. Message Queue的角色  在你的Android程序里，新诞生一个线程，或称执行(Thread)时，并不会自动建立其Message Loop。  Android里并没有Global的Message Queue数据结构，例如，不同APK里的对象不能透过Massage Queue来交换讯息(Message)。  一个线程可以诞生一个Looper之对象，由它来管理此线程里的Message Queue。  你可以诞生Handler之对象来与Looper沟通，以便push新讯息到Message Queue里；或者接收Looper(从Message Queue取出)所送来的讯息。  线程A的Handler对象参考可以传递给别的线程，让别的线程B或C等能送讯息来给线程A(存于A的Message Queue里)。  线程A的Message Queue里的讯息，只有线程A所属的对象可以处理之。  使用Looper.myLooper可以取得目前线程的Looper对象参考值。  使用mHandler = new EevntHandler(Looper.myLooper()); 可诞生用来处理目前线程的Handler对象；其中，EevntHandler是Handler的子类别。  使用mHandler = new EevntHandler(Looper.getMainLooper()); 可诞生用来处理main线程的Handler对象；其中，EevntHandler是Handler的子类别。
安卓 Handler面试（2）：MessageQueue的设计原理
dev晴天的博客
07-13 477
MessageQueue的设计原理（重要、重要、重要） 1、MessageQueue使用的数据结构？ 使用了单链表的数据结构来实现的，message可看做链表的节点，Message 的next成员来指向下条消息。MessageQueue涉及到两个重要的操作消息入队enqueueMessage、出队next。 2、正常来说队列的数据先进先出，既然使用了队列这种数据结构，那么他是如何保证延迟消息插入队列后 ，后续立即执行的消息插入后在他之前的执行的？读源码 ^- ^ MessageQueue#enqueueMe
android的消息处理机制(图文+源码分析)—Looper/Handler/Message
夜空里荡秋千的女孩
10-15 456
本文分两部分，第二部分是原文，第一部分是概括，
MessageQueue&Message Pool—消息的读写、删除和回收
加油吧 王小二
06-12 3133
1、MessageQueue的数据结构 翻译为消息队列，但实际的数据结构是单向链表结构，下文中仍以消息队列称之； Message中有个重要的属性Message next；next指向另外一个Message。在MessageQueue中Message A的next指向B，B的next指向C；这样 A B C就组成了单向链表结构，它们是以时间排序的，其中A为header，表示最先要处理的消息，C是
知识整理——消息队列
weixin_42547014的博客
04-15 1653
什么是消息队列 消息队列，一般我们会简称它为MQ(Message Queue) 我们先不管消息(Message)这个词，来看看队列(Queue)。这一看，队列大家应该都熟悉吧。 队列是一种先进先出的数据结构。 消息队列可以简单理解为：把要传输的数据放在队列中。 科普： 把数据放到消息队列叫做 生产者 从消息队列里边取数据叫做 消费者 为什么使用消息队列 消息队列常见的使用场景吧，其实场景有很多，但是比较核心的有 3 个：解耦、异步、削峰。 1.解耦 看这么个场景。A 系统发送数据到 BCD
android 的消息机制
一站到底s的博客
07-17 197
android的消息机制主要是指Handler的运行机制。 MessageQueue：消息队列，采用单链表的数据结构来存储消息队列 Looper：队列循环，会以无限循环的形式去查找是否有新消息，如果有新消息就处理，否则就一直等待着 ThreadLocal：每个线程中存储数据的，通过ThreadLoacl可以轻松获取每个线程Looper 注意：线程默认是没有Looper的，如果需要...
Android消息机制详解：Handler、MessageQueue、Looper
追yi流年
06-15 617
1、Handler的诞生背景 在Android中，规定了只能在主线程（或者叫UI线程）中，去进行UI相关的操作，而其他线程则无法操作UI，否则报错； 但同时，由于不能再UI线程进行耗时的操作，否则会报ANR异常， 因此，我们通常又把耗时操作放到子线程去进行一个处理。 那这就涉及到了一个数据传递的问题，我们在子线程处理的数据，怎么传递到主线程呢？这就有了Handler消息机制。 为什么要设计为只能在...
android 中 Handler 模块，MessageQueue 源码分析
Deaht_Huimie的博客
06-21 317
MessageQueue 是线程队列，作用接收 Handler 添加进来的 Message，按照规则排好序，同时对外（Looper）提供最近的 Message。队列里面装的是 Message，我们看一下最简化的 Message final class Message implements Parcelable { Message next; ... ...
android messagequeue 底层,理解android中的MessageQueue
weixin_30582943的博客
05-26 359
一 前言阅读本文的前提是你已经知道什么是Handler、Looper、ThreadLocal等基本类。源码位置可以在这里搜索。二 源码分析enqueueMessage方法分析boolean enqueueMessage(Message msg, long when) {if (msg.target == null) {throw new IllegalArgumentException("Mess...
深入理解Android消息机制：Looper、Handler与Message
在Android系统中，消息机制是实现线程间通信和异步处理的关键组件，它由Looper、Handler和Message这三个核心类组成，还有一个MessageQueue，虽然不直接操作，但它是Looper内部的重要组成部分。下面将逐一解析这些类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值