进程通信 订阅
进程通信是指在进程间传输数据(交换信息)。 [1]  进程通信根据交换信息量的多少和效率的高低,分为低级通信(只能传递状态和整数值)和高级通信(提高信号通信的效率,传递大量数据,减轻程序编制的复杂度)。其中高级进程通信分为三种方式:共享内存模式、消息传递模式、共享文件模式。 [1] 展开全文
进程通信是指在进程间传输数据(交换信息)。 [1]  进程通信根据交换信息量的多少和效率的高低,分为低级通信(只能传递状态和整数值)和高级通信(提高信号通信的效率,传递大量数据,减轻程序编制的复杂度)。其中高级进程通信分为三种方式:共享内存模式、消息传递模式、共享文件模式。 [1]
信息
分    类
操作系统
中文名
进程通信
进程通信原因
为了提高计算机系统的效率.增强计算机系统内各种硬件的并行操作能力.操作系统要求程序结构必须适应并发处理的需要.为此引入了进程的概念。进程是操作系统的核心,所有基于多道程序设计的操作系统都建立在进程的概念之上。目前的计算机系统均提供了多任务并行环境.无论是应用程序还是系统程序.都需要针对每一个任务创建相应的进程。进程是设计和分析操作系统的有力工具。然而不同的进程之间.即使是具有家族联系的父子进程.都具有各自不同的进程映像。由于不同的进程运行在各自不同的内存空间中.一方对于变量的修改另一方是无法感知的.因此.进程之间的信息传递不可能通过变量或其它数据结构直接进行,只能通过进程间通信来完成。并发进程之间的相互通信是实现多进程间协作和同步的常用工具.具有很强的实用性,进程通信是操作系统内核层极为重要的部分。
收起全文
精华内容
下载资源
问答
  • 进程通信

    千次阅读 2018-06-17 22:28:23
    进程通信是进程进行通信和同步的机制 基本操作 发送操作:send(message) 接受操作:receive(message) 进程通信流程 在通信进程间建立通信链路 通过send/receive交换信息 通信方式:间接通信和直接通信 ...

    一、概念

    进程通信是进程进行通信和同步的机制

    基本操作
    发送操作:send(message)
    接受操作:receive(message)

    进程通信流程
    ①在通信进程间建立通信链路
    ②通过send/receive交换信息

    通信方式:间接通信和直接通信
    这里写图片描述

    1.直接通信

    进程必须正确地命名对方进程
    send(P,message) P为接收方进程
    receive(Q,message) Q为发送方进程

    通信链路的属性

    • 自动建立链路
    • 一条链路对应一对通信进程

    2.间接通信

    通过操作系统维护的消息队列实现进程间的消息接受和发送
    send(A,message) 发送消息到消息队列A
    receive(A,message) 从消息队列A中接受消息

    通信链路的属性

    1. 每个消息队列都有唯一的标识
    2. 只有共享了相同消息队列的进程,才能通信
    3. 消息队列可以与多个进程相关联
    4. 每对进程可以共享多个消息队列

    3.阻塞通信和非阻塞通信

    阻塞通信(同步)
    阻塞发送:发送者在发送消息后进入等待,直到有接受者成功收到消息
    阻塞接受:接受者在请求接受消息后进入等待,直到成功收到消息

    非阻塞通信(异步)
    非阻塞发送:发送者在消息发送后,可立即进行其他操作
    非阻塞接受:没有消息发送时,接受者在请求接受消息后接受不到任何消息

    4.通信链路缓冲

    • 0容量:发送方必须等待接收方
    • 有限容量:通信链路缓冲队列满时,发送方必须等待
    • 无限容量:发送方不许等待

    5.四种通信机制

    信号、管道、消息队列、共享内存

    二、信号

    进程间的软件中断和处理机制(SIGKILL、SIGSTOP、SIGCONT等)
    不足:传送的信号量小、只有一个信号类型

    void sigproc(){
        signal(SIGINT,sigproc);
        printf("you have pressed ctrl-c \n");
    }
    main(){
        signal(SIGINT,sigproc);
        for(;;);
    }

    三、管道

    进程基于内存文件的通信机制

    • 子进程从父进程继承文件描述符
    • 缺省文件描述符:0 stdin、1 stdout、2 stderr
    • 进程不知道另一端的情况(可能从键盘、文件、程序读取,可写入终端、文件、程序)

    与管道相关的系统调用

    1. 读管道:read(fd,buffer,nbytes) scanf()是基于它实现的
    2. 写管道:write(fd,buffer,nbytes) print()是基于它实现的
    3. 创建管道:pipe(p)
      3.1. p是2个文件描述符组成的数组
      3.2. p[0]是读文件描述符
      3.3. p[1]是写文件描述符

    这里写图片描述

    四、消息队列

    消息队列是由操作系统维护的以字节序列为基本单位的间接通信机制

    • 每个消息是一个字节序列
    • 相同标识的消息按先进先出顺序组成一个消息队列

    这里写图片描述

    msgget(key,flags) 获取消息队列标识
    msgsnd(QID,buf,size,flags) 发送消息
    msgrcv(QID,buf,size,type,flags) 接受消息
    msgctl() 消息队列控制(创建、删除等)

    五、共享内存

    共享内存是把同一个物理内存区域同时映射到多个进程的内存地址空间的通信机制

    对于进程

    • 每个进程都有私有内存地址空间
    • 每个进程的内存地址空间需明确设置共享内存段

    对于线程

    • 同一进程的线程总是共享相同的内存地址空间

    优点:快速、方便地共享数据
    缺点:必须额外的同步机制来协调数据访问
    这里写图片描述
    shmget(key,size,flags) 创建共享段
    shmat(shmid,*shmaddr,flags) 把共享段映射到进程地址空间
    shmdt(*shmaddr) 取消共享段到进程地址空间的映射
    shmctl() 共享段控制

    展开全文
  • Android跨进程通信:图文详解 Binder机制 原理

    万次阅读 多人点赞 2017-06-22 10:31:24
    如果你接触过 跨进程通信 (IPC),那么你对Binder一定不陌生 虽然 网上有很多介绍 Binder的文章,可是存在一些问题:浅显的讨论Binder机制 或 一味讲解 Binder源码、逻辑不清楚,最终导致的是读者们还是无法形成一...

    前言

    • 如果你接触过 跨进程通信 (IPC),那么你对Binder一定不陌生
    • 虽然 网上有很多介绍 Binder的文章,可是存在一些问题:浅显的讨论Binder机制 或 一味讲解 Binder源码、逻辑不清楚,最终导致的是读者们还是无法形成一个完整的Binder概念
    • 本文采用 清晰的图文讲解方式,按照 大角度 -> 小角度 去分析Binder,即:
      1. 先从 机制、模型的角度 去分析 整个Binder跨进程通信机制的模型
      2. 再 从源码实现角度,分析 BinderAndroid中的具体实现

    从而全方位地介绍 Binder,希望你们会喜欢。

    请尽量在PC端而不要在移动端看,否则图片可能看不清。


    目录

    目录


    1. Binder到底是什么?

    • 中文即 粘合剂,意思为粘合了两个不同的进程

    • 网上有很多对Binder的定义,但都说不清楚:Binder是跨进程通信方式、它实现了IBinder接口,是连接 ServiceManager的桥梁blabla,估计大家都看晕了,没法很好的理解

    • 我认为:对于Binder的定义,在不同场景下其定义不同

    定义

    在本文的讲解中,按照 大角度 -> 小角度 去分析Binder,即:

    • 先从 机制、模型的角度 去分析 整个Binder跨进程通信机制的模型

    其中,会详细分析模型组成中的 Binder驱动

    • 再 从源码实现角度,分析 BinderAndroid中的具体实现

    从而全方位地介绍 Binder,希望你们会喜欢。


    2. 知识储备

    在讲解Binder前,我们先了解一些Linux的基础知识

    2.1 进程空间划分

    • 一个进程空间分为 用户空间 & 内核空间(Kernel),即把进程内 用户 & 内核 隔离开来
    • 二者区别:
      1. 进程间,用户空间的数据不可共享,所以用户空间 = 不可共享空间
      2. 进程间,内核空间的数据可共享,所以内核空间 = 可共享空间

    所有进程共用1个内核空间

    • 进程内 用户空间 & 内核空间 进行交互 需通过 系统调用,主要通过函数:
    1. copy_from_user():将用户空间的数据拷贝到内核空间
    2. copy_to_user():将内核空间的数据拷贝到用户空间

    示意图

    2.2 进程隔离 & 跨进程通信( IPC )

    • 进程隔离
      为了保证 安全性 & 独立性,一个进程 不能直接操作或者访问另一个进程,即Android的进程是相互独立、隔离的

    • 跨进程通信( IPC
      即进程间需进行数据交互、通信

    • 跨进程通信的基本原理

    示意图

    a. 而Binder的作用则是:连接 两个进程,实现了mmap()系统调用,主要负责 创建数据接收的缓存空间 & 管理数据接收缓存
    b. 注:传统的跨进程通信需拷贝数据2次,但Binder机制只需1次,主要是使用到了内存映射,具体下面会详细说明

    2.5 内存映射

    具体请看文章:操作系统:图文详解 内存映射


    3. Binder 跨进程通信机制 模型

    3.1 模型原理图

    Binder 跨进程通信机制 模型 基于 Client - Server 模式
    示意图

    3.2 模型组成角色说明

    示意图

    此处重点讲解 Binder驱动的作用 & 原理:

    • 简介

    示意图

    • 跨进程通信的核心原理

    关于其核心原理:内存映射,具体请看文章:操作系统:图文详解 内存映射

    示意图

    3.3 模型原理步骤说明

    示意图

    3.4 额外说明

    说明1:Client进程、Server进程 & Service Manager 进程之间的交互 都必须通过Binder驱动(使用 openioctl文件操作函数),而非直接交互

    原因:

    1. Client进程、Server进程 & Service Manager进程属于进程空间的用户空间,不可进行进程间交互
    2. Binder驱动 属于 进程空间的 内核空间,可进行进程间 & 进程内交互

    所以,原理图可表示为以下:

    虚线表示并非直接交互

    示意图

    说明2: Binder驱动 & Service Manager进程 属于 Android基础架构(即系统已经实现好了);而Client 进程 和 Server 进程 属于Android应用层(需要开发者自己实现)

    所以,在进行跨进程通信时,开发者只需自定义Client & Server 进程 并 显式使用上述3个步骤,最终借助 Android的基本架构功能就可完成进程间通信

    示意图

    说明3:Binder请求的线程管理
    • Server进程会创建很多线程来处理Binder请求
    • Binder模型的线程管理 采用Binder驱动的线程池,并由Binder驱动自身进行管理

    而不是由Server进程来管理的

    • 一个进程的Binder线程数默认最大是16,超过的请求会被阻塞等待空闲的Binder线程。

    所以,在进程间通信时处理并发问题时,如使用ContentProvider时,它的CRUD(创建、检索、更新和删除)方法只能同时有16个线程同时工作


    • 至此,我相信大家对Binder 跨进程通信机制 模型 已经有了一个非常清晰的定性认识
    • 下面,我将通过一个实例,分析Binder跨进程通信机制 模型在 Android中的具体代码实现方式

    即分析 上述步骤在Android中具体是用代码如何实现的


    4. Binder机制 在Android中的具体实现原理

    • Binder机制在 Android中的实现主要依靠 Binder类,其实现了IBinder 接口

    下面会详细说明

    • 实例说明:Client进程 需要调用 Server进程的加法函数(将整数a和b相加)

    即:

    1. Client进程 需要传两个整数给 Server进程
    2. Server进程 需要把相加后的结果 返回给Client进程
    • 具体步骤
      下面,我会根据Binder 跨进程通信机制 模型的步骤进行分析

    步骤1:注册服务

    • 过程描述
      Server进程 通过Binder驱动 向 Service Manager进程 注册服务
    • 代码实现
      Server进程 创建 一个 Binder 对象
    1. Binder 实体是 Server进程 在 Binder 驱动中的存在形式
    2. 该对象保存 ServerServiceManager 的信息(保存在内核空间中)
    3. Binder 驱动通过 内核空间的Binder 实体 找到用户空间的Server对象
    • 代码分析
        
        Binder binder = new Stub();
        // 步骤1:创建Binder对象 ->>分析1
    
        // 步骤2:创建 IInterface 接口类 的匿名类
        // 创建前,需要预先定义 继承了IInterface 接口的接口 -->分析3
        IInterface plus = new IPlus(){
    
              // 确定Client进程需要调用的方法
              public int add(int a,int b) {
                   return a+b;
             }
    
              // 实现IInterface接口中唯一的方法
              public IBinder asBinder(){ 
                    return null ;
               }
    };
              // 步骤3
              binder.attachInterface(plus,"add two int");
             // 1. 将(add two int,plus)作为(key,value)对存入到Binder对象中的一个Map<String,IInterface>对象中
             // 2. 之后,Binder对象 可根据add two int通过queryLocalIInterface()获得对应IInterface对象(即plus)的引用,可依靠该引用完成对请求方法的调用
            // 分析完毕,跳出
    
    
    <-- 分析1:Stub类 -->
        public class Stub extends Binder {
        // 继承自Binder类 ->>分析2
    
              // 复写onTransact()
              @Override
              boolean onTransact(int code, Parcel data, Parcel reply, int flags){
              // 具体逻辑等到步骤3再具体讲解,此处先跳过
              switch (code) { 
                    case Stub.add: { 
    
                           data.enforceInterface("add two int"); 
    
                           int  arg0  = data.readInt();
                           int  arg1  = data.readInt();
    
                           int  result = this.queryLocalIInterface("add two int") .add( arg0,  arg1); 
    
                            reply.writeInt(result); 
    
                            return true; 
                      }
               } 
          return super.onTransact(code, data, reply, flags); 
    
    }
    // 回到上面的步骤1,继续看步骤2
    
    <-- 分析2:Binder 类 -->
     public class Binder implement IBinder{
        // Binder机制在Android中的实现主要依靠的是Binder类,其实现了IBinder接口
        // IBinder接口:定义了远程操作对象的基本接口,代表了一种跨进程传输的能力
        // 系统会为每个实现了IBinder接口的对象提供跨进程传输能力
        // 即Binder类对象具备了跨进程传输的能力
    
            void attachInterface(IInterface plus, String descriptor);
            // 作用:
              // 1. 将(descriptor,plus)作为(key,value)对存入到Binder对象中的一个Map<String,IInterface>对象中
              // 2. 之后,Binder对象 可根据descriptor通过queryLocalIInterface()获得对应IInterface对象(即plus)的引用,可依靠该引用完成对请求方法的调用
    
            IInterface queryLocalInterface(Stringdescriptor) ;
            // 作用:根据 参数 descriptor 查找相应的IInterface对象(即plus引用)
    
            boolean onTransact(int code, Parcel data, Parcel reply, int flags);
            // 定义:继承自IBinder接口的
            // 作用:执行Client进程所请求的目标方法(子类需要复写)
            // 参数说明:
            // code:Client进程请求方法标识符。即Server进程根据该标识确定所请求的目标方法
            // data:目标方法的参数。(Client进程传进来的,此处就是整数a和b)
            // reply:目标方法执行后的结果(返回给Client进程)
             // 注:运行在Server进程的Binder线程池中;当Client进程发起远程请求时,远程请求会要求系统底层执行回调该方法
    
            final class BinderProxy implements IBinder {
             // 即Server进程创建的Binder对象的代理对象类
             // 该类属于Binder的内部类
            }
            // 回到分析1原处
    }
    
    <-- 分析3:IInterface接口实现类 -->
    
     public interface IPlus extends IInterface {
              // 继承自IInterface接口->>分析4
              // 定义需要实现的接口方法,即Client进程需要调用的方法
             public int add(int a,int b);
    // 返回步骤2
    }
    
    <-- 分析4:IInterface接口类 -->
    // 进程间通信定义的通用接口
    // 通过定义接口,然后再服务端实现接口、客户端调用接口,就可实现跨进程通信。
    public interface IInterface
    {
        // 只有一个方法:返回当前接口关联的 Binder 对象。
        public IBinder asBinder();
    }
      // 回到分析3原处
    

    注册服务后,Binder驱动持有 Server进程创建的Binder实体

    步骤2:获取服务

    • Client进程 使用 某个 service前(此处是 相加函数),须 通过Binder驱动 向 ServiceManager进程 获取相应的Service信息
    • 具体代码实现过程如下:

    示意图

    此时,Client进程与 Server进程已经建立了连接

    步骤3:使用服务

    Client进程 根据获取到的 Service信息(Binder代理对象),通过Binder驱动 建立与 该Service所在Server进程通信的链路,并开始使用服务

    • 过程描述

      1. Client进程 将参数(整数a和b)发送到Server进程
      2. Server进程 根据Client进程要求调用 目标方法(即加法函数)
      3. Server进程 将目标方法的结果(即加法后的结果)返回给Client进程
    • 代码实现过程

    步骤1: Client进程 将参数(整数a和b)发送到Server进程

    // 1. Client进程 将需要传送的数据写入到Parcel对象中
    // data = 数据 = 目标方法的参数(Client进程传进来的,此处就是整数a和b) + IInterface接口对象的标识符descriptor
      android.os.Parcel data = android.os.Parcel.obtain();
      data.writeInt(a); 
      data.writeInt(b); 
    
      data.writeInterfaceToken("add two int");;
      // 方法对象标识符让Server进程在Binder对象中根据"add two int"通过queryLocalIInterface()查找相应的IInterface对象(即Server创建的plus),Client进程需要调用的相加方法就在该对象中
    
      android.os.Parcel reply = android.os.Parcel.obtain();
      // reply:目标方法执行后的结果(此处是相加后的结果)
    
    // 2. 通过 调用代理对象的transact() 将 上述数据发送到Binder驱动
      binderproxy.transact(Stub.add, data, reply, 0)
      // 参数说明:
        // 1. Stub.add:目标方法的标识符(Client进程 和 Server进程 自身约定,可为任意)
        // 2. data :上述的Parcel对象
        // 3. reply:返回结果
        // 0:可不管
    
    // 注:在发送数据后,Client进程的该线程会暂时被挂起
    // 所以,若Server进程执行的耗时操作,请不要使用主线程,以防止ANR
    
    
    // 3. Binder驱动根据 代理对象 找到对应的真身Binder对象所在的Server 进程(系统自动执行)
    // 4. Binder驱动把 数据 发送到Server 进程中,并通知Server 进程执行解包(系统自动执行)
    
    

    步骤2:Server进程根据Client进要求 调用 目标方法(即加法函数)

    // 1. 收到Binder驱动通知后,Server 进程通过回调Binder对象onTransact()进行数据解包 & 调用目标方法
      public class Stub extends Binder {
    
              // 复写onTransact()
              @Override
              boolean onTransact(int code, Parcel data, Parcel reply, int flags){
              // code即在transact()中约定的目标方法的标识符
    
              switch (code) { 
                    case Stub.add: { 
                      // a. 解包Parcel中的数据
                           data.enforceInterface("add two int"); 
                            // a1. 解析目标方法对象的标识符
    
                           int  arg0  = data.readInt();
                           int  arg1  = data.readInt();
                           // a2. 获得目标方法的参数
                          
                           // b. 根据"add two int"通过queryLocalIInterface()获取相应的IInterface对象(即Server创建的plus)的引用,通过该对象引用调用方法
                           int  result = this.queryLocalIInterface("add two int") .add( arg0,  arg1); 
                          
                            // c. 将计算结果写入到reply
                            reply.writeInt(result); 
                            
                            return true; 
                      }
               } 
          return super.onTransact(code, data, reply, flags); 
          // 2. 将结算结果返回 到Binder驱动
    
    
    

    步骤3:Server进程 将目标方法的结果(即加法后的结果)返回给Client进程

      // 1. Binder驱动根据 代理对象 沿原路 将结果返回 并通知Client进程获取返回结果
      // 2. 通过代理对象 接收结果(之前被挂起的线程被唤醒)
    
        binderproxy.transact(Stub.ADD, data, reply, 0);
        reply.readException();;
        result = reply.readInt();
              }
    }
    
    • 总结
      下面,我用一个原理图 & 流程图来总结步骤3的内容

    原理图

    流程图


    5. 优点

    对比 LinuxAndroid基于Linux)上的其他进程通信方式(管道、消息队列、共享内存、
    信号量、Socket),Binder 机制的优点有:
    示意图


    6. 总结

    • 本文主要详细讲解 跨进程通信模型 Binder机制 ,总结如下:

    定义

    特别地,对于从模型结构组成的Binder驱动来说:

    示意图

    • 整个Binder模型的原理步骤 & 源码分析

    示意图

    Carson带你学Android 文章系列:
    Carson带你学Android:页面活动-Activity
    Carson带你学Android:广播-BroadcastReceiver
    Carson带你学Android:服务-Service
    Carson带你学Android:内存承载器-ContentProvider


    欢迎关注Carson_Ho的CSDN博客 与 公众号!

    博客链接:https://carsonho.blog.csdn.net/


    请帮顶 / 评论点赞!因为你的鼓励是我写作的最大动力!

    展开全文
  • 进程通信 进程通信

    2009-11-24 07:51:50
    进程通信 进程通信 进程通信 进程通信 进程通信 进程通信
  • 进程通信实验报告进程通信实验报告进程通信实验报告进程通信实验报告进程通信实验报告进程通信实验报告
  • 进程通信概念和进程通信方式

    万次阅读 2017-05-08 19:11:01
    进程通信(IPC,Inter-Porcess Communcation)是进程进行通信和同步的机制。IPC提供两个基本操作: 发送(send message) 接收(receive message) 进程通信流程: 在通信进程之间建立通信链路 通过send/receive交换...

    进程通信(IPC,Inter-Porcess Communcation)是进程进行通信和同步的机制。

    IPC提供两个基本操作:

    1. 发送(send message)
    2. 接收(receive message)

    进程通信流程:

    • 在通信进程之间建立通信链路
    • 通过send/receive交换信息

    进程通信方式:

    这里写图片描述

    直接通信:
    进程必须正确命名对方,比如send(p,message)向p发送信息,receive(q,message)从q中接收信息
    通信链路有如下属性:自动建立连接;一条链路恰好对应一对通信进程;每对进程之间只有一个链接存在;链路可以是单向的,但是通常为双向的

    间接通信:
    通过OS维护的消息队列实现进程之间的通信(接收发送信息)
    每个消息队列都有一个唯一标识,只有共享了相同消息队列的进程才能够通信
    通信链路有如下属性:只有共享了相同消息队列的进程才能建立连接,比如send(a,message)向消息队列a发送信息,receive(a,message)从消息队列a中接收信息 ;连接单向或者双向;消息队列可以与多个进程相互关联;每个进程共享多个消息队列(也就是进程和消息队列是多对多的关系)

    阻塞通信(同步)与非阻塞通信(异步)

    同步通信:

    阻塞发送:发送者发送消息后进入等待(阻塞)直到接受者成功接受
    阻塞接收:接收者请求接收信息后等待(阻塞)直到成功接受一条消息
    

    异步通信:

    非阻塞发送:发送者发送消息后,可立即进行其他操作
    非阻塞接收:接收者请求接收信息后,如果没有消息发送就接收不到信息,不需要等待
    

    通信链路缓冲:

    1. 0容量:发送方必须等待接受方
    2. 有限容量:缓冲队列满,发送方必须等待
    3. 无限容量:发送方不需要等待


    上面是关于IPC通信的基本概念,下面我们看一看一些常见的进程通信方式。

    MOOC讲了四种进程通信方式:

    信号,管道, 消息队列, 共享内存,由于都是基本概念,我偷个懒直接复制下来了:


    信号:

    这里写图片描述


    管道:

    这里写图片描述

    这里写图片描述

    这里写图片描述


    消息队列:

    这里写图片描述

    这里写图片描述


    共享内存:

    这里写图片描述

    这里写图片描述

    这里写图片描述

    展开全文
  • 易语言源码易语言进程通信模块源码.rar 易语言源码易语言进程通信模块源码.rar 易语言源码易语言进程通信模块源码.rar 易语言源码易语言进程通信模块源码.rar 易语言源码易语言进程通信模块源码.rar 易语言源码...
  • 易语言模块_模块_进程通信类.rar 易语言模块_模块_进程通信类.rar 易语言模块_模块_进程通信类.rar 易语言模块_模块_进程通信类.rar 易语言模块_模块_进程通信类.rar 易语言模块_模块_进程通信类.rar
  • 进程通信方式总结与盘点

    万次阅读 多人点赞 2019-11-20 14:25:23
    进程通信是指进程之间的信息交换。这里需要和进程同步做一下区分,进程同步控制多个进程按一定顺序执行,进程通信是一种手段,而进程同步是目标。从某方面来讲,进程通信可以解决进程同步问题。 ​ 首先回顾下...

    ​ 进程通信是指进程之间的信息交换。这里需要和进程同步做一下区分,进程同步控制多个进程按一定顺序执行,进程通信是一种手段,而进程同步是目标。从某方面来讲,进程通信可以解决进程同步问题。

    ​ 首先回顾下我们前面博文中讲到的信号量机制,为了实现进程的互斥与同步,需要在进程间交换一定的信息,因此信号量机制也可以被归为进程通信的一种方式,但是也被称为低级进程通信,主要原因为:

    1. 效率低:一次只可操作少量的共享数据,比如生产者消费者问题,生产者一次只可向缓冲池中投放一个消息;
    2. 通信对用户不透明:OS只为进程提供了共享存储器,而关于进程之间通信所需的共享数据结构的设计、数据的传递、进程的互斥与同步,都必须要有开发者去实现,显然,这对开发者来说很不方便,增加了程序设计的难度和复杂度。

    ​ 既然是说到了低级进程通信,并且解释了原因,那我们也来看一下高级进程通信的特点:

    1. 使用方便:这也是针对低级进程通信中的第二点—通信对用户不透明,OS对开发者隐藏了进程通信的具体细节,对于用户来说,只需要使用有OS提供的一组原语(实现高级通信的命令),就可以方便的直接使用并实现进程间的通信。就像我么使用第三方的jar包一样,直接调用封装好的方法即可。
    2. 高效的传送大量数据:可以通过OS提供的原语快速的传输大量数据。

    ​ 说完了两种级别的进程通信,下面我们就具体的来看一看进程的通信方式都有哪些。通信机制也是随着OS的发展而不断进步的,目前通信机制可分为四大类:共享存储器系统、管道通信系统、消息传递系统以及客户机-服务器系统。我们依次来进行讲解,对于下面出现的每种通信方式,我们采用序号来进行标记。

    共享存储器系统

    ​ 在共享存储器系统中,相互通信的进程共享某些数据结构或共享存储区,进程之间能够通过这些空间进行通信。因此按照共享内容的不同,可将其分为以下两种类型:

    1.基于共享数据结构的通信方式

    ​ 也称为我们上面讲到的信号量机制,此方式要求诸进程共用某些数据结构,借以实现进程间的信息交换,共享数据结构的一个例子就是存放消息的共享缓冲池,对其的操作需要使用信号量来保证诸进程间同步的进行。

    2.基于共享数据区的通信方式

    ​ 为了传输大量数据,OS在内存中划出一块共享存储区域,诸进程通过该共享区域读或写交换信息,实现通信。数据的形式、位置、访问控制都是由进程来控制的。需要通信的进程在通信前,先向系统申请获得共享存储区的一个分区,并将其附加到自己的地址空间中(如果不添加,访问时会产生地址越界中断,后续的内存管理中进行详细讲解),便可对其中的数据进行正常的读、写,操作完成或者不在需要时,再讲分区归还给共享存储区。也因为其一次可以操作一个分区,并可将大量的数据读取或者写入分区,所以这种方式也属于高级通信。另外因为数据不需要在进程之间复制,所以这是最快的一种进程通信机制

    管道(pipe)通信系统

    ​ 所谓“管道”是指连接一个读进程和一个写进程以实现他们之间通信的一个共享文件,又名pipe文件。管道系统可分为两种:

    3.无名管道

    ​ 这是Unix早期的一种通信方式,是半双工通信,只能用于父子进程或兄弟进程间,并且它不是普通的文件,并不属于其他任何文件系统,并且只存在于内存中。

    4.命名管道(FIFO)

    ​ 可以用于在无关进程间交换数据,FIFO也就是先进先出,有路径名与命名管道关联,它以一种特殊设备形式存在于文件系统中,并且可以实现半双工或全双工的通信。FIFO 常用于客户-服务器应用程序中,被作为汇聚点,在客户进程和服务器进程之间传递数据。

    消息传递系统

    ​ 在该机制中,进程不必借助任何共享存储区或数据结构,而是以格式化的消息(message)为单位,将通信的数据封装在消息中,并利用OS提供的一组通信原语,在进程间进行消息传递,完成进程间的数据交换。

    ​ 该方式隐藏了通信细节,使通信过程对用户透明化,降低了程序设计的复杂性和错误率,这也让它成为当前应用最广泛的一类进程间通信机制;并且该机制可以很好的支持多处理机系统、分布式系统和计算机网络,下面我们按照其实现方式,来分别讲解下消息传递系统:

    5.直接通信方式(消息缓冲队列)

    ​ 直接通信方式,是直接通过原语将消息发送到指定的进程,因此要求放松和接收的进程都必须以显示的方式提供对方的标识符。下面是两个OS提供的两条通信原语:

    send(receiver, message);   //发送一个消息给接收进程
    receive(sender, message);  //接收sender发来的消息
    

    ​ 下图是一个直接通信方式的示意图,图中可以很清晰的看到进程P1和P2各自发送了一条消息给对方,并从对方那接收了一条消息。

    ​ 需要注意的是,**消息缓冲队列通信机制**是直接通信的一种实现方式,而不是间接通信,因为其是将消息直接发送到指定进程中,如果消息没来得及被取走,就放入到消息缓冲队列中,因此和我们理解的ActiveMQ、RocketMQ是不同的。

    6.间接通信方式(消息队列)

    ​ 间接通信方式是指发送和接收进程都通过共享中间实体(OS中称为信箱)的方式进行消息的发送和接收,完成进程间的通信。

    ​ 我们来看下信箱通信的一个示意图,从图中我们可以看到,两个进程通过信箱来进行消息的发送和接收。

    ​ 我们现在常用的消息队列比如ActiveMQ、RocketMQ、RabbitMQ等,都是间接通信的一种,通过这种共享的中间实体(不一定要在当前主机的内存中),可以实现进程间的通信,并且可以很容易的实现不同主机上的进程通信。

    客户机-服务器系统

    ​ 讲到客户机-服务器系统,大家可能都会想到C/S架构,想到的可能是QQ或者WinForm等应用,但是C/S模式是一个逻辑上的概念,在进程通信中,发起请求的进程为客户机,进行响应的进程为服务器,在客户机-服务器系统中,除了客户机和服务器,还有用与连接所有客户机和服务器的网络系统。在网络环境的各种应用领域,客户机-服务器系统已经成为当前主流的通信机制。

    ​ 其主要的方法有三类:套接字、远程过程调用和远程方法调用。

    7.套接字(Socket)

    ​ 说起套接字大家应该都比较熟悉,ip+port,可以定位到哪个主机下的哪个进程,这样就可以对其进行请求,这个就是网络套接字。另一种套接字是文件套接字,基于本地文件系统实现的,一个套接字关联到一个特殊文件,通信双放通过这个文件进行读写实现通信,其原理类似管道。

    ​ 套接字的优势就在于,他不仅适用于同一台计算机内部的进程通信,也适用于网络环境中不同计算机间的进程通信;可以保证通信双方逻辑链路的唯一性(ip+port对ip+port可以保证逻辑链路唯一),并与实现数据传输的并发服务;隐藏了通信设施及实现细节,采用统一的接口进行处理。

    8.远程过程调用和远程方法调用(RPC)

    ​ 远程过程调用RPC(Remote Procedure Call)是一个通信协议,用于通过网络连接的系统。该协议允许运行于一台主机(本地)系统上的进程调用另一台主机(远程)系统上的进程,而对开发人员表现为常规的过程调用,无须额外的为此编程。如果设计的软件采用面向对象编程,也可称之为远程方法调用

    总结

    ​ 最后,我们对这几种通信方式进行一个总结,其中的某几种通信方式,被别的博主同一成了一个,比如消息传递系统中的直接通信和间接通信,统称为消息队列,这里不做正确性的评价,本文是把所有的通信机制大的方向做一个总结,具体的实现方式是有很多种的,故不做一一叙述。

    1.共享数据结构(信号量):仅适用于传递相对少量的数据,通信效率低,属于低级通信;

    2.共享存储区:允许多个进程共享一个给定的存储区,可以从中申请缓存区。因为数据不需要在进程之间复制,所以这是最快的一种通信机制,但要对诸进程的访问进行同步控制;

    3.无名管道:半双工、速度慢,容量有限,只有父子进程能通信;

    4.命名管道(FIFO):任何进程间都能通讯,但速度慢 ,可以实现半双工或全双工通信;

    5.消息缓冲队列:直接使用OS提供的原语,隐藏通信细节,需要知道接收进程的id和发送进程的id;

    6.消息队列:直接通过共享信箱或者队列,两个进程可以实现通信,可实现实时和非实时通信,两种消息传递系统容量都容易收到系统的限制;

    7.Socket:可以用于本机和不同主机间的进程通信,隐藏通信细节;

    8.RPC:无须额外编程,隐藏通信细节。


    ​ 又到了分隔线以下,本文到此就结束了,本文内容全部都是由博主自己进行整理并结合自身的理解进行总结,如果有什么错误,还请批评指正。对其中有什么疑惑的,可以评论区留言,欢迎你的留言与讨论;另外原创不易,如果本文对你有所帮助,还请留下个赞,以表支持。

    ​ 如有兴趣,还可以查看我的其他几篇博客,都是OS的干货(目录),喜欢的话还请点赞、评论加关注_

    展开全文
  • java 进程通信代码

    万次阅读 2018-08-03 10:50:16
    本人写了一个java进程通信的工具jar,方便大家简单的使用java进程通信。 开启守护进程,获取消息: package com.test; import org.msun.process.ProcessMonitor; import org.msun.process.ProcessMonitor....
  • Linux 进程通信

    万次阅读 2018-05-06 14:31:38
    Linux 进程通信 1.传统进程通信 1.1 信号 信号机制是在软件层次上对中断机制的一种模拟。 信号的捕获与处理也成为系统的“软中断”机制。 1.1.1 常用信号 每个信号都有一个编号和宏定义的名称,这些名字...
  • 进程通信之三 父进程传参数与子进程返回值》 http://blog.csdn.net/morewindows/article/details/8683830 配套程序。本篇介绍一个简单而又实用的进程通信方式——父进程向子进程传入参数并获取子进程返回值。这个...
  • 进程通信--总结

    2017-05-20 17:37:56
    进程通信的一些基本概念:进程通信概念和进程通信方式进程通信的几种方式:信号量:信号量(生产者和消费者模型) 和 信号量(进程通信)共享内存: 共享内存(进程通信)消息队列: 进程通信之消息队列管道:进程...
  • 操作系统进程通信实验

    千次阅读 2019-07-22 19:38:43
    通过 Linux 系统中管道通信机制,加深对于进程通信概念的理解,观察和体验 并发进程间的通信和协作的效果 ,练习利用无名管道进行进程通信的编程和调试 技术。 硬件环境 : window 软件环境: VWareUbuntu16.04 实验...
  • 本文参考于线程通信与进程通信的区别 。 进程和线程的区别:对于进程来说,子进程是父进程的复制品,从父进程那里获得父进程的数据空间,堆和栈的复制品。而线程,相对于进程而言,是一个更加接近于执行体的概念,...
  • 49-进程通信初步

    千次阅读 2016-12-29 21:46:01
    错综复杂的信号专题终于结束,能写到这里,感觉真不容易,甚至有点小激动,因为接下来进入进程间通信这个老生常谈的大专题。希望能有信心写好,因为我自己也有很多地方...作为进程通信的初步,我并不想以“管道通信”开
  • 自定义消息实现进程通信 使用MFC模拟实现进程间的通信,一个发送程序,一个接受程序,两个进程实现。
  • 实验一 进程管理与进程通信 一、实验目的 1、掌握进程的概念,明确进程的含义。 2、认识并了解进程并发执行的实质,进程的阻塞与唤醒,终止与退出的过程。 3、熟悉进程的睡眠、同步、撤消等进程控制方法。 4、分析...
  • IPC进程间通信/跨进程通信

    千次阅读 多人点赞 2019-02-16 09:50:36
    概念进程:一个JVM就是一个进程 线程:最小的调度单元 一个进程可以包含多个线程,在安卓中有一个主线程也就是UI线程,UI线程...比如Windows中通过剪贴板,管道,油槽等进行进程通信,Linux通过命名管道,共享内容
  • 进程通信(操作系统10)

    千次阅读 2020-10-08 11:21:01
    - 进程通信的三种方式的流程 - 共享存储、管道通信、消息传递的特点
  • 进程通信的类型

    千次阅读 2016-06-15 23:09:32
    3.5.1 进程通信的类型 1、进程通信的定义      进程之间的信息交换。   2、按进程通信机制发展来分     ◆ 低级进程通信机制     ◇ 少量...
  • 进程和进程通信

    2008-05-08 21:28:14
    2. 分别利用UNIX的消息通信机制、共享内存机制(用信号灯实施进程间的同步和互斥)实现两个进程间的数据通信。具体的通信数据可从一个文件读出,接收方进程可将收到的数据写入一个新文件,以便能判断数据传送的...
  • 操作系统之进程通信

    千次阅读 2020-02-09 13:20:34
    2.什么是进程通信 各进程的内存空间是相互独立的,一个进程不能访问另一个进程的内存空间。 但是进程间的相互通信是不可避免的 方案一 共享存储 为两个进程设立一个共享存储区,两个进程需要互斥(通过PV操作)的...
  • python多进程通信

    千次阅读 2018-03-29 21:34:41
    这是看书笔记python提供了多种进程通信的方式,比如说Queue,Pipe,Value+Array等。其中Queue主要用来在多个进程之间实现通信。Pipe常用来在两个进程之间实现通信。Queue是多进程安全队列,Queue通过put和get方法来...
  • 进程通信 操作系统 课程设计 进程通信 操作系统 课程设计
  • linux 进程通信

    千次阅读 2013-10-08 12:42:42
    进程通信有如下一些目的: A、数据传输:一个进程需要将它的数据发送给另一个进程,发送的数据量在一个字节到几M字节之间 B、共享数据:多个进程想要操作共享数据,一个进程对共享数据的修改,别的进程应该立刻...
  • Linux进程通信基本概念 从原理上来看,进程通信的关键技术就是在进程间建立某种共享区,利用进程都可以访问共享区的特点来建立一些通信通道。如下图所示: 其实,以前设计程序时使用的全局变量,就是一种可以在...
  • Linux——进程通信 一、实验目的 (1) 熟悉并掌握管道机制,并实现进程间通信 (2) 熟悉并掌握共享内存机制,并实现进程间通信 二、实验内容 任务一: (1)阅读以上父子进程利用管道进行通信的例子(例1),写...
  • Windows进程通信——Socket通信

    千次阅读 2017-06-06 14:35:32
    1. 概述 Windows Sockets规范是以U.C.Berkeley大学BSD UNIX中流行的Socket接口为范例定义的一套Windows下的网络编程接口。...现在通过Sockets实现进程通信的网络应用越来越多,这主要的原因是Sockets的
  • 广州大学2020操作系统实验一:进程管理与进程通信

    千次阅读 多人点赞 2020-07-24 17:15:57
    实验一 进程管理与进程通信 一、实验目的 1、掌握进程的概念,明确进程的含义。 2、认识并了解进程并发执行的实质,进程的阻塞与唤醒,终止与退出的过程。 3、熟悉进程的睡眠、同步、撤消等进程控制方法。 4、分析...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 592,513
精华内容 237,005
关键字:

进程通信