【Linux】进程间通信

2023-09-20 16:50:09

目录

一、进程间通信的目的

数据传输：一个进程需要将它的数据发送给另一个进程
资源共享：多个进程之间共享同样的资源。
通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

二、管道通信

1.匿名管道

通过打开同一个文件，父子进程对文件进行读写操作，父子进程在文件内核缓冲区中写入或读出数据，从而实现通信
在这里插入图片描述

创建匿名管道
在这里插入图片描述

pipe：创建一个管道，参数为输出型参数，打开两个文件描述符(fd)，返回值为0表示打开失败。

#include<iostream>
#include<string>
#include<cerrno>
#include<cassert>
#include<string.h>
#include<sys/types.h>
#include<unistd.h>

int main()
{
    int pipefd[2]={0};
    //1.创建管道
    int n=pipe(pipefd);
    if(n<0)
    {
        //创建不成功
        std::cout<<"pipe error, "<<errno<<":"<<strerror(errno)<<std::endl;
        return 1;
    }

    std::cout<<"pipefd[0]: "<<pipefd[0]<<std::endl; //读
    std::cout<<"pipefd[1]: "<<pipefd[1]<<std::endl; //写
    //2.创建子进程
    pid_t id=fork();
    assert(id!=-1); //省去判断
    if(id==0)
    {
        //子进程
        //3.关闭不需要的fd   父进程读取，子进程进行写入
        close(pipefd[0]);

        //4.开始通信
        std::string namestr="hello,我是子进程";
        int cnt=1;
        char buffer[1024];
        while(true)
        {
            snprintf(buffer,sizeof(buffer),"%s, 计数器：%d, 我的id: %d",namestr.c_str(),cnt++,getpid());
            write(pipefd[1],buffer,strlen(buffer));
            sleep(1);
        }

        exit(0); //子进程退出
    }
    
    //父进程
    //3.关闭不需要的fd   父进程读取，子进程进行写入
    close(pipefd[1]);

    //4.开始通信
    char buffer[1024];
    while(true)
    {
        //sleep(1);
        int n=read(pipefd[0],buffer,sizeof(buffer)-1);
        if(n>0)
        {
            //读取成功
            buffer[n]='\0';
            std::cout<<"我是父进程, child give me massage: "<<buffer<<std::endl;
            
        }
    }
    return 0;
}

在这里插入图片描述

子进程往内核缓冲区中写入数据，父进程读取数据，实现了简单的父子间进程通信。

管道的特点：
1.只能单向通信
2.面向字节流
3.只能在有"血缘"关系的进程中通信
4.管道也是文件，管道的生命周期随进程
5.管道自带同步系统，原子性写入

云服务器中，管道的大小为64KB，写端写满后不会再写，会等读端读取管道内容，且读取4KB后才会重新写入（读端的容量为4KB）

在这里插入图片描述

#include<iostream>
#include<string>
#include<cerrno>
#include<cassert>
#include<string.h>
#include<sys/types.h>
#include<unistd.h>

int main()
{
    int pipefd[2]={0};
    //1.创建管道
    int n=pipe(pipefd);
    if(n<0)
    {
        //创建不成功
        std::cout<<"pipe error, "<<errno<<":"<<strerror(errno)<<std::endl;
        return 1;
    }

    std::cout<<"pipefd[0]: "<<pipefd[0]<<std::endl; //读
    std::cout<<"pipefd[1]: "<<pipefd[1]<<std::endl; //写
    //2.创建子进程
    pid_t id=fork();
    assert(id!=-1); //省去判断
    if(id==0)
    {
        //子进程
        //3.关闭不需要的fd   父进程读取，子进程进行写入
        close(pipefd[0]);

        //4.开始通信
        std::string namestr="hello,我是子进程";
        int cnt=1;
        char buffer[1024];
        int count=0;
        char c='x';
        while(true)
        {
            //snprintf(buffer,sizeof(buffer),"%s, 计数器：%d, 我的id: %d",namestr.c_str(),cnt++,getpid());
            //write(pipefd[1],buffer,strlen(buffer));
            write(pipefd[1],&c,1);
            count++;
            printf("%d\n",count);
            //sleep(1);
        }

        exit(0); //子进程退出
    }
    
    //父进程
    //3.关闭不需要的fd   父进程读取，子进程进行写入
    close(pipefd[1]);

    //4.开始通信
    char buffer[1024];
    while(true)
    {
        sleep(3);
        int n=read(pipefd[0],buffer,sizeof(buffer)-1);
        if(n>0)
        {
            //读取成功
            buffer[n]='\0';
            std::cout<<"我是父进程, child give me massage: %d,"<<n<<buffer<<std::endl;
            
        }
    }
    return 0;
}

在这里插入图片描述

管道的读写规则

当没有数据可读时
O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。
O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。
当管道满的时候
O_NONBLOCK disable： write调用阻塞，直到有进程读走数据
O_NONBLOCK enable：调用返回-1，errno值为EAGAIN
如果所有管道写端对应的文件描述符被关闭，则read返回0 如果所有管道读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE,进而可能导致write进程退出
当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。
当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。
 
1.读端不读或读的慢，写端要等读端
2.读端关闭，写端收到SIGPIPE信号直接终止
3.写端不写或者写的慢，读端要等写端
4.写端关闭，读端会读完管道内的数据然后再读，会读到0，表示读道文件结尾

2.命名管道

匿名管道只能解决有 “血缘” 关系的进程之间通信
为解决这一问题，引入命名管道，可以实现没有 “血缘” 关系的进程也可以进行通信，
原理相同，使两个进程看到同一块内存。

①.创建命名管道

命令行创建
在这里插入图片描述
在这里插入图片描述

代码创建
这里是引用

 umask(0);
 if(mkfifo(pipe, 0666) < 0) //创建命名管道
 {
 	//创建失败
     perror("mkfifo");
     return 1;
 }

②.使用命名管道

进程一

#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

#define MAX 128

//实现两个进程进行相互通信


int main()
{ 

    //1.打开文件  对fifo文件进行只写
    int fd1=open("fifo",O_WRONLY);
    if(fd1==-1)
    {
        perror("open");
        return 1;
    }
    printf("已打开一个管道文件\n");

    char buf[MAX];
    int cnt=5;
    //2.写数据
    while(cnt)
    {
        memset(buf,0,MAX);
        sprintf(buf,"hello linux %d",cnt--);
        int ret=write(fd1,buf,strlen(buf));
        
        printf("write fifo : %d\n",ret);
        sleep(1);
    }
    close(fd1);

    return 0;
}

进程二

#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

#define MAX 128

int main()
{
    //1.打开管道
    int fd=open("fifo",O_RDONLY);
    if(fd==-1)
    {
        perror("open");
        return 1;
    }
    printf("以读方式打开一个管道\n");

    char buf[MAX];
    //2.读数据
    while(1)
    {
        memset(buf,0,MAX);
        int ret=read(fd,buf,MAX);
        if(ret<=0)//读到结尾
        {
            perror("read");
            break;
        }
        printf("buf:%s\n",buf);
    }

    //2.关闭文件
    close(fd);
    return 0;
}

运行两个程序，由此实现了两个进程的通信，如果想要实现相互通信，可以再开一个管道进行操作
在这里插入图片描述

三、system V 标准进程间通信

system V：同一主机内的进程间通信方案，在OS层面专门为进程间通信设计的方案

进程间通信的本质：让不同的进程看到同一份资源

system V标准下的三种通信方式 ①共享内存 ②消息队列 ③信号量

1.共享内存

实现原理

1.通过系统调用，在内存中创建一份内存空间
2.通过系统调用，让进程"挂接"到这份新开辟的内存空间上(即在页表上建立虚拟地址与物理地址的映射关系)
3.去关联(挂接)
4.释放共享内存

 

①常用接口

sheget :申请共享内存

在这里插入图片描述
返回值在这里插入图片描述

#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);
// key：创建共享内存时的算法和数据结构中唯一标识符，由用户自己设定需用到接口ftok
// size：共享内存的大小，建议是4KB的整数倍
// shmflg：有两个选项：IPC_CREAT(0)，创建一个共享内存，如果已经存在则返回共享内存；IPC_EXCL(单独使用没有意义)
// IPC_CREAT|IPC_EXCL(如果调用成功，一定会得到一个全新的共享内存)：如果不存在共享内存，就创建；反之，返回出错
// 返回值：shmdi，描述共享内存的标识符
​
 
#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id); // 算法生成key
// pathname：自定义路径名
// proj_id：自定义项目id

 

shmctl :控制共享内存

在这里插入图片描述
返回值在这里插入图片描述

#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
// shmid：共享内存id
// cmd：控制方式，这里我们只使用IPC_RMID 选项，表示删除共享内存
// buf：描述共享内存的数据结构

 

关联和去关联共享内存

在这里插入图片描述
返回值在这里插入图片描述

#include <sys/types.h>
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg); // 关联
// shmid：共享内存id
// shmaddr：挂接地址(自己不知道地址，所以默认为NULL)
// shmflg：挂接方式，默认为0
// 返回值：挂接成功返回共享内存起始地址(虚拟地址)，类似C语言malloc
​
    
int shmdt(const void *shmaddr); // 去关联(取消当前进程和共享内存的关系)
// shmaddr：去关联内存地址，即shmat返回值
// 返回值：调用成功返回0，失败返回-1

 

②共享内存的内核数据结构

共享内存是内存，操作系统同时是运行多个进程的，所以操作系统中有多个共享内存同时存在，操作系统如何管理这些内存文件？先描述，后组织，操作系统会定义一个struct shmid_ds的内核数据结构去管理这些打开的贡献内存。

在这里插入图片描述
 

③查看删除共享内存

指令查看共享内存:    ipcs -m
在这里插入图片描述

system V 的IPC资源，生命周期随内核，只能通过程序员显示释放(或者OS重启)
指令删除共享内存：  ipcrm -m shmid
在这里插入图片描述
也可使用指令shmctl进行共享内存删除操作

实现一个小demo通过内存共享实现进程间相互通信

comman.hpp

#ifndef __COMM_HPP__
#define __COMM_HPP__ 

#include<iostream>
#include<cerrno>
#include<cstdio>
#include<cassert>
#include<cstring>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/shm.h>

using namespace std;



#define PATHNAME "."
#define PROJID 0x6666

const int gsize=4096;


key_t getKey()
{
    key_t k=ftok(PATHNAME,PROJID);
    if(k==-1)
    {
        //失败
        cerr<<"error"<<errno<<":"<<strerror(errno)<<endl;
        exit(1);
    }
    return k;
}

string toHex(int x)
{
    char buffer[64];
    snprintf(buffer,sizeof(buffer),"0x%x",x);
    return buffer;
}

static int creatShmHelper(key_t k,int size,int flag)
{
    int shmid=shmget(k,size,flag);
    if(shmid==-1)
    {
        // 创建失败
        cerr<<"error: "<<errno<<": "<<strerror(errno)<<endl;
        exit(2);
    }
    return shmid;
}

//创建共享内存
//IPC_CREATE
//单独使用IPC_CREATE:创建一个共享内存，如果共享内存不存在，就创建之，如果已经存在，获取已经存在的共享内存并返回
//IPC_EXCL不能单独使用，一般配合IPC_CREATE
//IPC_CREATE | IPC_EXCL  :创建一个共享内存，如果不存在，就创建之，如果已经存在，立马出错返回，如果创建成功，返回创建好的共享内存
int creatShm(key_t k,int size)
{   
    umask(0);
    return creatShmHelper(k,size,IPC_CREAT|IPC_EXCL|0666);  //设置权限
}

//获取共享内存
int getShm(key_t k,int size)
{
    return creatShmHelper(k,size,IPC_CREAT);
}

void delShm(int shmid)
{
    int n=shmctl(shmid,IPC_RMID,nullptr);
    assert(n!=-1);
    (void)n;
}

char* attachShm(int shmid)
{
    char* start=(char*)shmat(shmid,nullptr,0);  
    return start;
} 

void detachShm(char* start)
{
    int n=shmdt(start);
    assert(n!=-1);
    (void)n;
}


#endif

shmserver.cc

#include"comman.hpp"
#include<unistd.h>

int main()
{  
    //1.创建key
    key_t k=getKey();
    cout<<"server:"<<toHex(k)<<endl;

    //2.创建共享内存
    int shmid=creatShm(k,gsize);
    cout<<"server shmid: "<<shmid<<endl;

    //3.将自己和共享内存关联起来
    char * start=attachShm(shmid);

    //通信代码 
     int n=0;
     while(n<=26)
     {
         cout<<"client -> server # "<<start<<endl;
         n++;
         sleep(1);
     }
    //sleep(3);

    //4.将自己和共享内存去关联
    detachShm(start);

    //删除共享内存
    delShm(shmid);
    return 0;
}

shmclient.cc

#include"comman.hpp"
#include<unistd.h>

int main()
{
    key_t k=getKey();
    cout<<"client:"<<toHex(k)<<endl;

    int shmid=getShm(k,gsize);
    cout<<"client shmid: "<<shmid<<endl;

    //3.将自己和共享内存关联起来
    char * start=attachShm(shmid);

    char c='A';
    while(c<='Z')
    {
        start[c-'A']=c;
        c++;
        start[c]='\0';
        sleep(1);
    }

    //4.将自己和共享内存去关联
    detachShm(start);

    sleep(5);
    return 0;
}

实现效果请添加图片描述

使用共享内存进行通信时，不需要使用read和write 接口。

共享内存是所有进程间通信中速度最快的。

共享内存不提供任何同步或互斥机制，需要程序员自行保证数据安全。

ps: 共享内存在内核中的申请的基本单位是页，内存页的大小为4KB，如果申请4097个字节，内核会分配8KB空间，但实际给使用的内存还是4097个字节。

更多推荐

开源在医疗健康领域的应用

🌷🍁博主猫头虎带您GotoNewWorld.✨🍁🦄博客首页——猫头虎的博客🎐🐳《面试题大全专栏》文章图文并茂🦕生动形象🦖简单易学！欢迎大家来踩踩~🌺🌊《IDEA开发秘籍专栏》学会IDEA常用操作，工作效率翻倍~💐🌊《100天精通Golang(基础入门篇）》学会Golang语言，畅玩云原生，走遍大

三维模型3DTile格式轻量化压缩的遇到常见问题与处理方法分析

三维模型3DTile格式轻量化压缩的遇到常见问题与处理方法分析三维模型的轻量化压缩是一项技术挑战，特别是在处理复杂的3DTile格式时。下面列举了一些处理过程中可能遇到的常见问题以及相应的处理方法：模型精度损失：在进行压缩处理时，由于顶点减少或数据精度降低，可能导致模型的精度损失，表现为模型变形或者细节丢失。对此，我们

基础数据结构与算法总结3（附有完整代码，适合小白）

目录前言13，哈希表14，二叉搜索树14.1，二叉搜索树完整代码如下15，平衡二叉树15.1，平衡二叉树完整代码如下：16，排序篇16.1，插入排序（稳定）16.2，插入排序完整代码16.3，冒泡排序（稳定）16.4，冒泡排序完整代码16.5，快速排序（不稳定）16.6，快速排序完整代码16.7，合并排序（稳定）16.

爬虫框架Scrapy学习笔记-2

前言Scrapy是一个功能强大的Python爬虫框架，它被广泛用于抓取和处理互联网上的数据。本文将介绍Scrapy框架的架构概览、工作流程、安装步骤以及一个示例爬虫的详细说明，旨在帮助初学者了解如何使用Scrapy来构建和运行自己的网络爬虫。爬虫框架Scrapy学习笔记-1文章目录前言Scrapy架构概览Scrapy工

OpenMV与STM32之间的通信（附源码）

本篇文章旨在记录我电赛期间使用openmv和stm32单片机之间进行串口通信，将openmv识别到的坐标传输给单片机。背景是基于2023年全国大学生电子设计大赛E题：舵机云台追踪识别。单片机的串口通信原理我便不再详细讲解，下面直接上代码分析。值得注意的是接线：RX——>TXTX——>RX单片机和OPENMV必须共地非常

Python爬虫技巧：使用代理IP和User-Agent应对反爬虫机制

在当今的网络环境中，反爬虫机制广泛应用于各个网站，为爬虫程序增加了困难。然而，作为一名Python爬虫开发者，我们可以利用一些技巧应对这些反爬虫措施。本文将分享一个重要的爬虫技巧：使用代理IP和User-Agent来应对反爬虫机制，帮助您更有效地进行数据爬取。1.使用代理IP许多网站通过监控来自同一IP地址的高频请求来

从零开始—【Mac系统】MacOS配置Java环境变量

系统环境说明AppleM1macOSVentura版本13.5.21.下载JDK安装包Oracle官网下载地址JDK下载【注：推荐下载JDK8Oracle官网JDK8下载】关于JDK、JRE、JVM的关系说明JDK(JavaDevelopmentKit，Java开发工具包)，是整个JAVA的核心，包括JRE，很多Jav

【C++】封装unordered_map和unordered_set（用哈希桶实现）

前言：前面我们学习了unordered_map和unordered_set容器，比较了他们和map、set的查找效率，我们发现他们的效率比map、set高，进而我们研究他们的底层是由哈希实现。哈希是一种直接映射的方式，所以查找的效率很快。与学习红黑树和map、set的思路一样，我们现在学完了unordered_map和

11:STM32---spl通信

目录一:SPL通信1:简历2:硬件电路3:移动数据图4:SPI时序基本单元A:开/终条件B:SPI时序基本单元A:模式0B:模式1C:模式2D:模式3C:SPl时序A:发送指令B:指定地址写C:指定地址读二:W25Q641:简历2:硬件电路3:W25Q64框图4:Flash操作注意事项5:指令集三:案例A:软件SPI读

Ceph入门到精通-CEPH故障以其处理方法

1.SlowOSDheartbeats#ceph-shealth:HEALTH_WARNSlowOSDheartbeatsonback(longest6181.010ms)SlowOSDheartbeatsonfront(longest5953.232ms)OSDs之间会相互测试（ping）访问速度，若两个OSDs之间

Docker 常用命令

帮助启动类命令1、启动docker：systemctlstartdocker2、停l止docker：systemctlstopdocker3、重启docker：systemctlrestartdocker4、查看docker状态：systemctlstatusdocker5、开机启动：systemctlenabledo

热文推荐
  1. 【EI检索会议】第四届智能电网与能源工程国际研讨会（SGEE 2023）

    第四届智能电网与能源工程国际研讨会（SGEE2023）20234thInternationalConferenceonSmartGridandEnergyEngineering继往届SGEE年度系列会议的成功举办，所录用论文已完成出版及检索。第四届智能电网与能源工程国际研讨会将于2023年11月24日-26日在河南郑州

  2. 如何构建一个 NodeJS 影院微服务并使用 Docker 部署

    文章目录前言什么是微服务？构建电影目录微服务构建微服务从NodeJS连接到MongoDB数据库总结前言如何构建一个NodeJS影院微服务并使用Docker部署。在这个系列中，将构建一个NodeJS微服务，并使用DockerSwarm集群进行部署。以下是将要使用的工具：NodeJS版本7.2.0MongoDB3.4.1D

  3. ChatGPT：字符串操作问题——提取包含括号的字符串中的题干内容

    ChatGPT：字符串操作问题——提取包含括号的字符串中的题干内容Stringtitle=p.text().split(“(”)[0];为什么会报错ChatGPT：在这段代码中，您正在使用Java处理一个字符串（假设是HTML或文本），尝试将其分割成两部分，其中一个是从左括号"("之前的内容。这段代码的目的是提取标题，

  4. 消息队列（三）：硬盘管理

    我在第一章提到过：关于持久化那一块，在内存存储主要是获取比较方便，在硬盘上存储主要是为了长时间存储。关于内存管理又分两部分：数据库管理和文件管理（主要是和消息有关）。硬盘管理硬盘中的数据库管理其实在上一章的建库建表说过了，就这么几步，SQLite+MyBatis几十行代码就搞定了除此之外就是对其进行一个封装即可。这里的

  5. K8S名称空间和资源配额

    Kubernetes支持多个虚拟集群，底层依赖于同一个物理集群。这些虚拟集群被称为名称空间。名称空间namespace是k8s集群级别的资源，可以给不同的用户、租户、环境或项目创建对应的名称空间，例如，可以为test、dev、prod环境分别创建各自的命名空间。当多个用户或团队共享具有固定节点数目的集群时，人们会担心有

  6. 5.k8s jenkins集成k8s一键发布案例

    文章目录前言一、jenkins配置1.1jenkins配置git1.2jenkins配置maven1.3jenkins配置java二、jenkins流水线配置2.1.新增项目2.2springboot项目配置git仓库2.3springboot项目配置maven打包2.4系统配置ssh到hadoop1配置，也就是k8s

  7. MYSQL01高级_Linux版安装、各级别字符集、字符集与比较规则、SQL大小写规范

    文章目录①.MySQL-linux版安装②.字符集的相关操作③.各级别的字符集④.字符集与比较规则(了解)⑤.SQL大小写规范⑥.sql_mode的合理设置①.MySQL-linux版安装①.进入mysql官网,找到安装文件②.将抽取出来的文件放在linux下的opt下MySQLCommunityServer社区版本,

  8. 创邻科技，位居IDC MarketScape中国图数据库市场领导者类别

    图数据库，正进入市场发展的新阶段。随着中国经济社会数字化转型加速，数据成为新型生产要素。如何存储并管理海量数据，挖掘数据价值，打破原有增长天花板，成为企业重塑商业价值的关键。存量经济时代更需要深层关系挖掘，打造更深刻的客户洞察和画像，从点、面、网来做网络分析。作为数字化企业构建相对竞争优势的关键技术，图数据库正大步迈进

  9. 企业级通用低代码开发平台——一二三应用开发平台发布4.2开源版本，回顾与展望

    背景今年三月初，确定了自己将来很长一段时间要做的事情，再启程，从头开始，研发一套应用开发平台，完全开源，详见https://blog.csdn.net/seawaving/article/details/129334330。从头开始，不是从零开始，大量的技术选型工作，平台设计与实现工作，都已实现，需要的大多是迁移和优化