进程间通信 Messenger

2024-06-16 09:48
文章标签 间通信 进程 messenger

本文主要是介绍进程间通信 Messenger，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

使用Messenger进行通信的方式要比aidl写起来方便的多，这种方式大概的流程为：



这种方式可以做到双向通信


那么下面就是代码了，首先是服务端：我自己的测试的项目在另一台电脑上，所以就拿借鉴的博主的代码来了，其实

我自己写的是差不多的

[java]  view plain copy
  1. package com.example.aidlClientdemo;  
  2.   
  3. import android.app.Service;  
  4. import android.content.Intent;  
  5. import android.os.Handler;  
  6. import android.os.HandlerThread;  
  7. import android.os.IBinder;  
  8. import android.os.Message;  
  9. import android.os.Messenger;  
  10. import android.os.RemoteException;  
  11.   
  12. public class ProcessCommonicationService extends Service{  
  13.     private static final int MSG_SUM = 0x110;  
  14.       
  15.     HandlerThread handlerThread = new HandlerThread("myHandlerThread");         
  16.   
  17.     //这里在handler构造器内传入handlerThread的Lopper，可以让handleMessage在handlerThread的线程内队列执行  
  18.     private Messenger mMessenger = new Messenger(new Handler(handlerThread.getLooper())  
  19.     {  
  20.         @Override  
  21.         public void handleMessage(Message msgfromClient)  
  22.         {  
  23.             Message msgToClient = Message.obtain(msgfromClient);//返回给客户端的消息  
  24.             switch (msgfromClient.what)  
  25.             {  
  26.                 //msg 客户端传来的消息  
  27.                 case MSG_SUM:  
  28.                     msgToClient.what = MSG_SUM;  
  29.                     try  
  30.                     {  
  31.                         //模拟耗时  
  32.                         Thread.sleep(2000);  
  33.                         msgToClient.arg2 = msgfromClient.arg1 + msgfromClient.arg2;  
  34.                         msgfromClient.replyTo.send(msgToClient);  
  35.                     } catch (InterruptedException e)  
  36.                     {  
  37.                         e.printStackTrace();  
  38.                     } catch (RemoteException e)  
  39.                     {  
  40.                         e.printStackTrace();  
  41.                     }  
  42.                     break;  
  43.             }  
  44.   
  45.             super.handleMessage(msgfromClient);  
  46.         }  
  47.     });  
  48.       
  49.     @Override  
  50.     public void onCreate() {  
  51.         super.onCreate();  
  52.         //使用handlerThread可以进行队列执行  
  53.         handlerThread.start();  
  54.     }  
  55.   
  56.     @Override  
  57.     public IBinder onBind(Intent intent)  
  58.     {  
  59.         return mMessenger.getBinder();  
  60.     }  
  61. }  

客户端代码结束之后就是服务端的代码

[java]  view plain copy
  1. package com.imooc.messenger_client;  
  2.   
  3. import android.content.ComponentName;  
  4. import android.content.Context;  
  5. import android.content.Intent;  
  6. import android.content.ServiceConnection;  
  7. import android.os.Bundle;  
  8. import android.os.Handler;  
  9. import android.os.IBinder;  
  10. import android.os.Message;  
  11. import android.os.Messenger;  
  12. import android.os.RemoteException;  
  13. import android.support.v7.app.AppCompatActivity;  
  14. import android.util.Log;  
  15. import android.view.View;  
  16. import android.widget.Button;  
  17. import android.widget.LinearLayout;  
  18. import android.widget.TextView;  
  19.   
  20. public class MainActivity extends AppCompatActivity  
  21. {  
  22.     private static final String TAG = "MainActivity";  
  23.     private static final int MSG_SUM = 0x110;  
  24.   
  25.     private Button mBtnAdd;  
  26.     private LinearLayout mLyContainer;  
  27.     //显示连接状态  
  28.     private TextView mTvState;  
  29.   
  30.     private Messenger mService;  
  31.     private boolean isConn;  
  32.   
  33.   
  34.     private Messenger mMessenger = new Messenger(new Handler()  
  35.     {  
  36.         @Override  
  37.         public void handleMessage(Message msgFromServer)  
  38.         {  
  39.             switch (msgFromServer.what)  
  40.             {  
  41.                 case MSG_SUM:  
  42.                     TextView tv = (TextView) mLyContainer.findViewById(msgFromServer.arg1);  
  43.                     tv.setText(tv.getText() + "=>" + msgFromServer.arg2);  
  44.                     break;  
  45.             }  
  46.             super.handleMessage(msgFromServer);  
  47.         }  
  48.     });  
  49.   
  50.   
  51.     private ServiceConnection mConn = new ServiceConnection()  
  52.     {  
  53.         @Override  
  54.         public void onServiceConnected(ComponentName name, IBinder service)  
  55.         {  
  56.             mService = new Messenger(service);  
  57.             isConn = true;  
  58.             mTvState.setText("connected!");  
  59.         }  
  60.   
  61.         @Override  
  62.         public void onServiceDisconnected(ComponentName name)  
  63.         {  
  64.             mService = null;  
  65.             isConn = false;  
  66.             mTvState.setText("disconnected!");  
  67.         }  
  68.     };  
  69.   
  70.     private int mA;  
  71.   
  72.     @Override  
  73.     protected void onCreate(Bundle savedInstanceState)  
  74.     {  
  75.         super.onCreate(savedInstanceState);  
  76.         setContentView(R.layout.activity_main);  
  77.   
  78.         //开始绑定服务  
  79.         bindServiceInvoked();  
  80.   
  81.         mTvState = (TextView) findViewById(R.id.id_tv_callback);  
  82.         mBtnAdd = (Button) findViewById(R.id.id_btn_add);  
  83.         mLyContainer = (LinearLayout) findViewById(R.id.id_ll_container);  
  84.   
  85.         mBtnAdd.setOnClickListener(new View.OnClickListener()  
  86.         {  
  87.             @Override  
  88.             public void onClick(View v)  
  89.             {  
  90.                 try  
  91.                 {  
  92.                     int a = mA++;  
  93.                     int b = (int) (Math.random() * 100);  
  94.   
  95.                     //创建一个tv,添加到LinearLayout中  
  96.                     TextView tv = new TextView(MainActivity.this);  
  97.                     tv.setText(a + " + " + b + " = caculating ...");  
  98.                     tv.setId(a);  
  99.                     mLyContainer.addView(tv);  
  100.   
  101.                     Message msgFromClient = Message.obtain(null, MSG_SUM, a, b);  
  102.                     msgFromClient.replyTo = mMessenger;  
  103.                     if (isConn)  
  104.                     {  
  105.                         //往服务端发送消息  
  106.                         mService.send(msgFromClient);  
  107.                     }  
  108.                 } catch (RemoteException e)  
  109.                 {  
  110.                     e.printStackTrace();  
  111.                 }  
  112.             }  
  113.         });  
  114.   
  115.     }  
  116.   
  117.     private void bindServiceInvoked()  
  118.     {  
  119.         Intent intent = new Intent();  
  120.         intent.setAction("com.zhy.aidl.calc");  
  121.         bindService(intent, mConn, Context.BIND_AUTO_CREATE);  
  122.         Log.e(TAG, "bindService invoked !");  
  123.     }  
  124.   
  125.     @Override  
  126.     protected void onDestroy()  
  127.     {  
  128.         super.onDestroy();  
  129.         unbindService(mConn);  
  130.     }  
  131.   
  132.   
  133. }  


在上面的例子中，是传递了基本类型的参数，而我们实际使用中则很多都会需要用到传递自定义类型，这种时候只需要这么做就行了

[java]  view plain copy
  1. Message msgFromClient = Message.obtain(null, MSG_SUM, a, b);  
  2.         msgFromClient.replyTo = mMessenger;  
  3.         Bundle bundle = new Bundle();  
  4.         bundle.putParcelable("data", new User());  
  5.         msgFromClient.setData(bundle);  
  6.           
  7.         if (isConn)  
  8.         {  
  9.             //往服务端发送消息  
  10.             mService.send(msgFromClient);  
  11.         }  
就是通过在Message中添加Bundle来传递我们自定义的对象，这个对象需要实现Parcelable接口


通过上面的方式可以方便的进行进程间的通讯


那么，为什么通过这种方式可以进行进程间通讯呢？这一点在我解读的文章中也有描述


之前我了解过aidl的进程通讯方式，在aidl的通讯方式可以发现与这里非常相似


1、bindService的方式

2、ServiceConnection的使用

3、aidl接口的对象获取，其实可以发现这里也是一样的

这里调用的通讯方式为Messenger mService = new Messenger(service);

而aidl的接口对象获取方式为：ICalcAIDL mCalcAidl = ICalcAIDL.Stub.asInterface(service);

表面上看起来好像有点不同，但是，如果我们去看Messenger的构造器

[java]  view plain copy
  1. public Messenger(IBinder target) {  
  2.         mTarget = IMessenger.Stub.asInterface(target);  
  3.     }  


这里返回的mTarget对象为

private final IMessenger mTarget;

跟aidl客户端的方式一模一样，在调用通讯方法send(Message message)我们再去看

[java]  view plain copy
  1. public void send(Message message) throws RemoteException {  
  2.         mTarget.send(message);  
  3.     }  
很明显，其实内部的逻辑方式就是使用的aidl



那么客户端我们发现了是一样的，再去看服务端呢？

在服务端我们的代码是

[java]  view plain copy
  1. private Messenger mMessenger = new Messenger(new Handler(handlerThread.getLooper())  
  2. {  
  3.     @Override  
  4.     public void handleMessage(Message msgfromClient)  
  5.     {  
  6.         Message msgToClient = Message.obtain(msgfromClient);//返回给客户端的消息  
  7.         switch (msgfromClient.what)  
  8.         {  
  9.             //msg 客户端传来的消息  
  10.             case MSG_SUM:  
  11.                 msgToClient.what = MSG_SUM;  
  12.                 try  
  13.                 {  
  14.                     //模拟耗时  
  15.                     Thread.sleep(2000);  
  16.                     msgToClient.arg2 = msgfromClient.arg1 + msgfromClient.arg2;  
  17.                     msgfromClient.replyTo.send(msgToClient);  
  18.                 } catch (InterruptedException e)  
  19.                 {  
  20.                     e.printStackTrace();  
  21.                 } catch (RemoteException e)  
  22.                 {  
  23.                     e.printStackTrace();  
  24.                 }  
  25.                 break;  
  26.         }  
  27.   
  28.         super.handleMessage(msgfromClient);  
  29.     }  
  30. });  
然后是

[java]  view plain copy
  1. @Override  
  2. public IBinder onBind(Intent intent)  
  3. {  
  4.     return mMessenger.getBinder();  
  5. }  


而aidl的通讯方式是

[java]  view plain copy
  1. private final ICalcAIDL.Stub mBinder = new ICalcAIDL.Stub()    
  2.     {    
  3.     
  4.         @Override    
  5.         public int add(int x, int y) throws RemoteException    
  6.         {    
  7.             return x + y;    
  8.         }    
  9.     
  10.         @Override    
  11.         public int min(int x, int y) throws RemoteException    
  12.         {    
  13.             return x - y;    
  14.         }    
  15.     
  16.     };    

然后

[java]  view plain copy
  1. public IBinder onBind(Intent t)    
  2. {    
  3.     Log.e(TAG, "onBind");    
  4.     return mBinder;    
  5. }    
就是将一个实现了我们自定义的aidl对象的Stub接口的对象作为通讯方式返回


那么，现在的Messenger方式又是怎样的呢

我们首先来看Messenger的构造器，来看看这这里面做了什么

[java]  view plain copy
  1. public Messenger(Handler target) {  
  2.        mTarget = target.getIMessenger();  
  3.    }  
这里从我们传入的handler中取出了IMessenger对象


这个IMessenger，其实是依赖一个aidl生成的类

于：frameworks/base/core/java/android/os/IMessenger.aidl.

[java]  view plain copy
  1. package android.os;    
  2.   
  3. import android.os.Message;    
  4.   
  5. /** @hide */    
  6. oneway interface IMessenger {    
  7.     void send(in Message msg);    
  8. }    

这样，在服务端就只差一个东西了，就是实现了 IMessenger.Stub的对象，这个对象我们去哪里找？

然后我们去看

[java]  view plain copy
  1. public Messenger(Handler target) {  
  2.        mTarget = target.getIMessenger();  
  3.    }  

这里的target.getMessenger()方法，我们进去看一下，可以看到

[java]  view plain copy
  1. final IMessenger getIMessenger() {  
  2.     synchronized (mQueue) {  
  3.         if (mMessenger != null) {  
  4.             return mMessenger;  
  5.         }  
  6.         mMessenger = new MessengerImpl();  
  7.         return mMessenger;  
  8.     }  
  9. }  
  10.   
  11.  private final class MessengerImpl extends IMessenger.Stub {  
  12.     public void send(Message msg) {  
  13.         msg.sendingUid = Binder.getCallingUid();  
  14.         Handler.this.sendMessage(msg);  
  15.     }  
  16. }  
找到了！这个MessengerImpl对象就是实现了IMessenger.Stub的对象


这样一来，需要的要素就都齐了，按照现在的代码来推测的话，不难推测出

[java]  view plain copy
  1. @Override  
  2. public IBinder onBind(Intent intent)  
  3. {  
  4.     return mMessenger.getBinder();  
  5. }  
这里返回的mMessenger.getBinder()应该是 MessengerImpl对象，不过我们还是得去确认一下


[java]  view plain copy
  1. public IBinder getBinder() {  
  2.     return mTarget.asBinder();  
  3. }  

这里调用了asBinder()方法，再进去看

[java]  view plain copy
  1. @Override public android.os.IBinder asBinder()  
  2. {  
  3. return this;  
  4. }  
可以看到，asBinder方法就是返回的mTarget对象自己，就是 MessengerImpl对象


这里这个asBinder方法的源码是aidl文件在gen路径下生成的类里面可以看到的，如果读者想看的话，可以在aidl的例子中查看，就可以看到


那么Messenger配合Handler的进程间通信的原理到这里就分析结束了，从这个看来的话，其实我们完全也可以自己写一个类似于Messenger的对象用来进行进程间通信，并且利用Message可以传递数据的特性来进行数据的传递，可以说还是非常方便的

这篇关于进程间通信 Messenger的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1066121。

相关文章

C#如何优雅地取消进程的执行之Cancellation详解

C#如何优雅地取消进程的执行之Cancellation详解

《C#如何优雅地取消进程的执行之Cancellation详解》本文介绍了.NET框架中的取消协作模型,包括CancellationToken的使用、取消请求的发送和接收、以及如何处理取消事件... 目录概述与取消线程相关的类型代码举例操作取消vs对象取消监听并响应取消请求轮询监听通过回调注册进行监听使用Wa
阅读更多...
[Linux]：进程(下)

[Linux]：进程(下)

✨✨ 欢迎大家来到贝蒂大讲堂✨✨ 🎈🎈养成好习惯，先赞后看哦~🎈🎈 所属专栏：Linux学习 贝蒂的主页：Betty’s blog 1. 进程终止 1.1 进程退出的场景 进程退出只有以下三种情况： 代码运行完毕，结果正确。代码运行完毕，结果不正确。代码异常终止（进程崩溃）。 1.2 进程退出码 在编程中，我们通常认为main函数是代码的入口，但实际上它只是用户级
阅读更多...
java 进程 返回值

java 进程 返回值

实现 Callable 接口 与 Runnable 相比，Callable 可以有返回值，返回值通过 FutureTask 进行封装。 public class MyCallable implements Callable<Integer> {public Integer call() {return 123;}} public static void main(String[] args
阅读更多...
C#关闭指定时间段的Excel进程的方法

C#关闭指定时间段的Excel进程的方法

private DateTime beforeTime;            //Excel启动之前时间          private DateTime afterTime;               //Excel启动之后时间          //举例          beforeTime = DateTime.Now;          Excel.Applicat
阅读更多...
linux中使用rust语言在不同进程之间通信

linux中使用rust语言在不同进程之间通信

第一种：使用mmap映射相同文件 fn main() {let pid = std::process::id();println!(
阅读更多...
java线程深度解析（二）——线程互斥技术与线程间通信

java线程深度解析（二）——线程互斥技术与线程间通信

http://blog.csdn.net/daybreak1209/article/details/51307679      在java多线程——线程同步问题中，对于多线程下程序启动时出现的线程安全问题的背景和初步解决方案已经有了详细的介绍。本文将再度深入解析对线程代码块和方法的同步控制和多线程间通信的实例。 一、再现多线程下安全问题 先看开启两条线程，分别按序打印字符串的
阅读更多...
Golang进程权限调度包runtime

Golang进程权限调度包runtime

关于 runtime 包几个方法: Gosched：让当前线程让出 cpu 以让其它线程运行,它不会挂起当前线程，因此当前线程未来会继续执行GOMAXPROCS：设置最大的可同时使用的 CPU 核数Goexit：退出当前 goroutine(但是defer语句会照常执行)NumGoroutine：返回正在执行和排队的任务总数GOOS：目标操作系统NumCPU：返回当前系统的 CPU 核数量 p
阅读更多...
如何保证android程序进程不到万不得已的情况下，不会被结束

如何保证android程序进程不到万不得已的情况下，不会被结束

最近，做一个调用系统自带相机的那么一个功能，遇到的坑，在此记录一下。 设备：红米note4 问题起因 因为自定义的相机，很难满足客户的所有需要，比如：自拍杆的支持，优化方面等等。这些方面自定义的相机都不比系统自带的好，因为有些系统都是商家定制的，难免会出现一个奇葩的问题。比如：你在这款手机上运行，无任何问题，然而你换一款手机后，问题就出现了。 比如：小米的红米系列，你启用系统自带拍照功能后
阅读更多...
flume系列之：记录一次flume agent进程被异常oom kill -9的原因定位

flume系列之：记录一次flume agent进程被异常oom kill -9的原因定位

flume系列之：记录一次flume agent进程被异常oom kill -9的原因定位 一、背景二、定位问题三、解决方法 一、背景 flume系列之：定位flume没有关闭某个时间点生成的tmp文件的原因，并制定解决方案在博主上面这篇文章的基础上，在机器内存、cpu资源、flume agent资源都足够的情况下，flume agent又出现了tmp文件无法关闭的情况 二、
阅读更多...
C++及AIDL服务间通信相关

C++及AIDL服务间通信相关

只做细节展示，没有什么逻辑，陆续补充中
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2