Android 中Message,MessageQueue,Looper,Handler详解

最新推荐文章于 2024-03-31 11:40:53 发布
最新推荐文章于 2024-03-31 11:40:53 发布
阅读量487 收藏
点赞数
文章标签： android handler me
一、几个关键概念

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
/*http://www.jcodecraeer.com*/
    
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) {  
                      
                 Looper looper = Looper.getMainLooper(); //主线程的Looper对象  
                 //这里以主线程的Looper对象创建了handler，  
                 //所以，这个handler发送的Message会被传递给主线程的MessageQueue。  
                 handler = new MyHandler(looper);  
                 handler.removeMessages(0);  
                 //构建Message对象  
                 //第一个参数：是自己指定的message代号，方便在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);  
         }  
     }  
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
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( "我是主线程的Handler，收到了消息：" +(String)msg.obj);  
         }  
     }  
          
     //加了一个线程类  
     class MyThread extends Thread{  
              
         public void run(){  
             Looper looper = Looper.getMainLooper(); //主线程的Looper对象  
             //这里以主线程的Looper对象创建了handler，  
             //所以，这个handler发送的Message会被传递给主线程的MessageQueue。  
             handler = new MyHandler(looper);  
      
             //构建Message对象  
             //第一个参数：是自己指定的message代号，方便在handler选择性地接收  
             //第二三个参数没有什么意义  
             //第四个参数需要封装的对象  
             Message msg = handler.obtainMessage(1,1,1, "其他线程发消息了" );  
                  
             handler.sendMessage(msg); //发送消息              
         }  
     }  
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
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);  
             }  
         }  
     }  
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
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);                  
                 }  
      
             }  
         }  
     }  
}

附注：
上面四个例子的布局文件是同一个文件main.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?xml version= "1.0" encoding= "utf-8" ?>  
<LinearLayout xmlns:android= "http://schemas.android.com/apk/res/android"
     android:rientation= "vertical"
     android:layout_width= "fill_parent"
     android:layout_height= "fill_parent"
     >  
<TextView  android:id= "@+id/view_01"
     android:layout_width= "fill_parent" 
     android:layout_height= "wrap_content" 
     android:text= "@string/hello"
     />  
          
<Button android:id= "@+id/btn_01" 
     android:layout_width= "fill_parent" 
     android:layout_height= "wrap_content" 
     android:text= "测试消息" />  
</LinearLayout>
xxdecc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深入Android Handler,MessageQueue与Looper关系
01-05
一说到Android的消息机制，自然就会联想到Handler，我们知道Handler是Android消息机制的上层接口，因此我们在开发过程中也只需要和Handler交互即可，很多人认为Handler的作用就是更新UI,这也确实没错，但除了更新UI...
Android 消息机制之 MessageQueue 消息队列
hust_twj的专栏
02-20 2413
ss
MessageQueue Message Looper Handler的解释说明
weixin_33966365的博客
08-07 59
总结4个关键概念 1、MessageQueue：是一种数据结构，见名知义，就是一个消息队列，存放消息的地方。每一个线程最多只可以拥有一个MessageQueue数据结构。创建一个线程的时候，并不会自动创建其MessageQueue。通常使用一个Looper对象对该线程的MessageQueue进行管理。主线程创建时，会创建一个默认的Looper对象，而Loope...
Android 总结：Message,MessageQueue,Looper,Handler 消息机制
最新发布
2401_83977357的博客
03-31 980
Android架构学习进阶是一条漫长而艰苦的道路，不能靠一时激情，更不是熬几天几夜就能学好的，必须养成平时努力学习的习惯。所以：贵在坚持！上面分享的字节跳动公司2021年的面试真题解析大全，笔者还把一线互联网企业主流面试技术要点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节。【Android高级架构视频学习资源】Android部分精讲视频领取学习后更加是如虎添翼！进军BATJ大厂等（备战）！
android线程间消息处理机制(Handler,Looper,MessageQueue,Message)
fengzi
03-21 766
多线程交互机制
Android Handler机制——MessageQueue
qq_38401088的博客
03-20 615
Android Handler机制——MessageQueue 一、构造 Message mMessages; private final boolean mQuitAllowed; private long mPtr; // used by native code MessageQueue(boolean quitAllowed) { mQuitAllowed = quitAllowed; mPtr = nativeInit(); }   从MessageQueue的构造可以看出，其主要是两个参数
微服务学习之rockectmq
Herry_Xia的博客
09-15 1113
rocketmq的安装 安装配置 jdk8 上传jdk压缩文件 将文件jdk-8u212-linux-x64.tar.gz上传到 /root 目录 2. 解压缩 执行解压命令 #将jdk解压到 /usr/local/ 目录 tar -xf jdk-8u212-linux-x64.tar.gz -C /usr/local/ #切换到 /usr/local/ 目录, 显示列表, 查看解压缩的jdk目录 cd /usr/local 配置环境变量 修改 /etc/profile 配置文件, 配置环境变量
Message,MessageQueue,Looper,Handler详解
02-22
Message,MessageQueue,Looper,Handler详解
AsyncTask陷阱之:Handler,Looper与MessageQueue的详解
09-05
本篇文章是对Handler,Looper与MessageQueue进行了详细的分析介绍，需要的朋友参考下
Message,MessageQueue,Looper,Handler详解[归类].pdf
10-11
Message,MessageQueue,Looper,Handler详解[归类].pdf
Android消息处理机制Looper和Handler详解
01-04
Message：消息，其中包含了消息ID，消息处理对象以及处理的数据等，由MessageQueue统一列队，终由Handler处理。 Handler：处理者，负责Message的发送及处理。...Looper：消息泵，不断地从MessageQueue中抽取
Android MessageQueue用法及分析
Qq2179344的博客
01-17 595
MessageQueue（boolean quitallowed）方法，实例化传递过来的false会赋值到当前queue的boolean类型的mQuitAllowed变量，该变量标记是否能退出消息队列。mPtr变量会从nativeInit（）方法获取值。finalize()方法，该方法内容try里执行 dispose方法 finally执行super.finalize（）。无catchdispose（）方法，该方法会判断当前queue里面的一个long类型变量mPtr。
Android消息机制（5）MessageQueue深入解析
安静的奥里维
07-15 1178
介绍 前面的博客已经简要分析了Handler，Looper，MessageQueue的大体框架，我们已经知道，Handler主要作用是封装Message的发送和接收，Looper的功能是不断轮询MessageQueue,取出Message交给对应的Handler执行，而消息队列的休眠，唤醒，及我们比较少用到的IdleHandler，同步屏障等功能都是由MessageQueue实现的，所以下面就来详细分析上述功能是如何实现的。 IdleHandler 首先是IdleHandler，IdleHandler是一个
Android应用程序的消息处理机制(MessageQueue,Looper,Handler)
u012906122的专栏
06-24 810
Android应用程序是通过消息驱动的。应用程序的每个线程启动时，会在内部创建一个消息队列，然后再进入到一个无限循环中。如果有新的消息需要处理，那么线程就会将它从消息队列中取出来处理；否则，线程进入睡眠状态，直到有新的消息需要处理为止。 Android系统主要通过MessageQueue,Looper和Handler三个类来实现Android应用程序的消息处理。MessageQueue类用来描述消息队列，Looper类用来创建消息队列，进入消息循环；Handler类用来发送消息和处理消息。 1 创.
Android消息机制（Handler、Looper、MessageQueue）
walk的博客
11-16 628
ThreadLocal 是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，数据存储以后，只有在指定线程中可以获取到存储的数据，对于其他线程来说则无法获取到数据。一般来说，当某些数据是以线程为作用域并且不同线程具有不同的数据副本的时候，就可以考虑采用 ThreadLocal。
Android中MessageQueue实现原理浅析
05-07
循序渐进的介绍Android中MessageQueue的实现原理。并且介绍MessageQueue中所涉及到的重要知识点。
Android_Architecture_HIDL(General)--Fast Message Queue (FMQ) 快速消息队列
Change The World
03-02 652
说明：转载自官方英文+中文版https://source.android.com/devices/architecture/hidl/fmq   Fast Message Queue (FMQ) 快速消息队列 HIDL’s remote procedure call (RPC) infrastructure uses Binder mechanisms, meaning calls invol...
请帮我设计一个Android应用设计思路，涉及到Handler、Message、Message Queue、Looper
06-07
好的，我可以帮你设计一个Android应用，它可以接收用户输入的文字，并在后台进行处理，最终将处理结果返回给用户。 首先，我们需要在UI线程中创建一个Handler对象，并让它与主线程的MessageQueue关联起来。这样，我们就可以将处理消息的任务交给Handler来完成。代码如下： ```java Handler handler = new Handler(Looper.getMainLooper()) { @Override public void handleMessage(Message msg) { // 处理消息 } }; ``` 接下来，我们需要在后台线程中创建一个Looper对象，并使用它来创建一个Handler对象。这样，我们就可以将处理消息的任务放到后台线程中完成。代码如下： ```java new Thread(new Runnable() { @Override public void run() { Looper.prepare(); Handler handler = new Handler() { @Override public void handleMessage(Message msg) { // 处理消息 } }; Looper.loop(); } }).start(); ``` 最后，我们需要在用户输入文字时，将消息发送到后台线程中的Handler对象中去。代码如下： ```java handler.sendEmptyMessage(MSG_TEXT_CHANGED); ``` 在后台线程中，当Handler收到这个消息时，就可以开始处理用户输入的文字了。处理完成后，可以使用Handler对象的sendMessage方法将处理结果返回给UI线程。 这就是一个基于Handler、Message、MessageQueue、Looper的Android应用的设计思路。希望能对你有所帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值