进程间通信

已于 2023-04-01 16:42:19 修改
阅读量93 收藏
点赞数
文章标签： linux c++ Powered by 金山文档
于 2023-03-22 22:48:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62147567/article/details/129720510
版权

进程间通信的概念：

在Linux环境下，进程地址空间是相互独立的，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所有不同进程间不能互相访问，要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据拷到内核缓冲区中，进程2再从缓冲据中把数据读走，内核提供的这种机制称为进程间通信。

进程间通信的方式

常用的进程间通信方式有：

管道（使用最简单）

信号（开销最小）

共享映射区（无血缘关系）

本地套接字（最稳定）

管道-pipe

管道的概念：管道是一种最基本的IPC机制，也称匿名管道，应用于有血缘关系的进程之间，完成数据传递。调用pipe函数即可创建一个管道。

管道的本质是一块内核缓冲区，内部用环形队列实现

由两个文件描述符引起，一个表示读端，一个表示写端

规定数据从写端流入管道，从读端流出

当两个进程都终结的时候，管道也自动消失

管道的读端和写端默认都是阻塞的

管道的局限性：

管道中的数据一旦被读走就不在管道中了，不能反复读取。

数据只能在一个方向上流动，若要实现双向流动，必须使用两个管道

只能在有血缘关系的进程间使用管道

pipe函数

int pipe(int fd[2]);//若函数调用成功，fd[0]存放管道的读端，fd[1]存放管道的写端

父子进程使用管道通信

第一步：父进程创建管道

第二步：父进程fork出子进程

第三步：父进程关闭读端，子进程关闭写端

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>

int main()
{
    //创建管道
    //int pipe(int pipefd[2]);
    int fd[2];
    int ret = pipe(fd);
    if(ret<0)
    {
        perror("pipe error");
        return -1;
    }

    //创建子进程
    pid_t pid = fork();
    if(pid<0) 
    {
        perror("fork error");
        return -1;
    }
    else if(pid>0)
    {
        //关闭读端
        close(fd[0]);
        sleep(5);
        write(fd[1], "hello world", strlen("hello world"));    

        wait(NULL);
    }
    else 
    {
        //关闭写端
        close(fd[1]);
        
        char buf[64];
        memset(buf, 0x00, sizeof(buf));
        int n = read(fd[0], buf, sizeof(buf));
        printf("read over, n==[%d], buf==[%s]\n", n, buf);
    
    }

    return 0;
}

父子进程通信实现ps aux | grep bash

//使用pipe完成ps aux | grep bash操作
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>

int main()
{
    //创建管道
    //int pipe(int pipefd[2]);
    int fd[2];
    int ret = pipe(fd);
    if(ret<0)
    {
        perror("pipe error");
        return -1;
    }

    //创建子进程
    pid_t pid = fork();
    if(pid<0) 
    {
        perror("fork error");
        return -1;
    }
    else if(pid>0)
    {
        //关闭读端
        close(fd[0]);

        //将标准输出重定向到管道的写端
        dup2(fd[1], STDOUT_FILENO);
        
        execlp("ps", "ps", "aux", NULL);

        perror("execlp error");
    }
    else 
    {
        //关闭写端
        close(fd[1]);
    
        //将标准输入重定向到管道的读端
        dup2(fd[0], STDIN_FILENO);

        execlp("grep", "grep", "--color=auto", "bash", NULL);

        perror("execlp error");
    }

    return 0;
}

FIFO

FIFO被称为命名管道，可以用于不相关的进程间通信

创建管道

方式1：使用命名 mkfifo

命令格式： mkfifo 管道名

方式2：使用函数

int mkfifo(const char *pathname, mode_t mode)

使用FIFO完成两个进程间通信

  • 进程A：

  • 创建一个fifo文件：myfifo

  • 调用open函数打开myfifo文件

  • 调用write函数写入一个字符串如：“hello world”（其实是将数据写入到了内核缓冲区）

  • 调用close函数关闭myfifo文件

  • 进程B：

  • 调用open函数打开myfifo文件

  • 调用read函数读取文件内容（其实就是从内核中读取数据）

  • 打印显示读取的内容

  • 调用close函数关闭myfifo文件

fifo_write

//fifo完成两个进程间通信的测试
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

int main()
{
    //创建fifo文件
    //int mkfifo(const char *pathname, mode_t mode);
    int ret = access("./myfifo", F_OK);
    if(ret!=0)
    {        
        ret = mkfifo("./myfifo", 0777);
        if(ret<0)
        {
            perror("mkfifo error");
            return -1;
        }
    }

    //打开文件
    int fd = open("./myfifo", O_RDWR);
    if(fd<0)
    {
        perror("open error");
        return -1;
    }

    //写fifo文件
    int i = 0;
    char buf[64];
    while(1)
    {
        memset(buf, 0x00, sizeof(buf));
        sprintf(buf, "%d:%s", i, "hello world");
        write(fd, buf, strlen(buf));
        sleep(1);

        i++;
    }

    //关闭文件
    close(fd);

    //getchar();

    return 0;
}

fifo_read

//fifo完成两个进程间通信的测试
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

int main()
{
    //创建fifo文件
    //int mkfifo(const char *pathname, mode_t mode);
    //判断myfofo文件是否存在,若不存在则创建
    int ret = access("./myfifo", F_OK);
    if(ret!=0)
    {
        ret = mkfifo("./myfifo", 0777);
        if(ret<0)
        {
            perror("mkfifo error");
            return -1;
        }
    }

    //打开文件
    int fd = open("./myfifo", O_RDWR);
    if(fd<0)
    {
        perror("open error");
        return -1;
    }

    //读fifo文件
    int n;
    char buf[64];
    while(1)
    {
        memset(buf, 0x00, sizeof(buf));
        n = read(fd, buf, sizeof(buf));
        printf("n==[%d], buf==[%s]\n", n, buf);
    }

    //关闭文件
    close(fd);

    //getchar();

    return 0;
}

内存映射区

存储映射I/O使一个磁盘文件与存储空间中的一个缓冲区像映射。

映射工作可以通过mmap函数实现

mmap函数的作用是建立存储缓冲区

函数原型：

void *mmap(void *addr, size_t length, int prot, int flags, intfd, off_t offset)

函数返回的是创建的映射区的首地址

  • addr: 指定映射的起始地址, 通常设为NULL, 由系统指定

  • length：映射到内存的文件长度

  • prot： 映射区的保护方式, 最常用的:

  • 读：PROT_READ

  • 写：PROT_WRITE

  • 读写：PROT_READ | PROT_WRITE

  • flags： 映射区的特性, 可以是

  • MAP_SHARED: 写入映射区的数据会写回文件, 且允许其他映射该文件的进程共享。

  • MAP_PRIVATE: 对映射区的写入操作会产生一个映射区的复制(copy-on-write), 对此区域所做的修改不会写回原文件。

  • fd：由open返回的文件描述符, 代表要映射的文件。

  • offset：以文件开始处的偏移量, 必须是4k的整数倍, 通常为0, 表示从文件头开始映射。

munmap函数

函数的作用：释放由mmap函数建立的存储映射区

函数原型：

int munmap(void *addr,size_t length)//addr表示mmap函数返回的映射区首地址，length是映射区的大小

mmap_write

//使用mmap函数完成两个不相干进程间通信
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/mman.h>

int main()
{
    //使用mmap函数建立共享映射区
    //void *mmap(void *addr, size_t length, int prot, int flags,
    //              int fd, off_t offset);
    int fd = open("./test.log", O_RDWR);
    if(fd<0)
    {
        perror("open error");
        return -1;
    }

    int len = lseek(fd, 0, SEEK_END);

    //建立共享映射区
    void * addr = mmap(NULL, len, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    if(addr==MAP_FAILED)
    {
        perror("mmap error");
        return -1;
    }
    
    memcpy(addr, "0123456789", 10);

    return 0;
}

mmap_read

//使用mmap函数完成两个不相干进程间通信
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/mman.h>

int main()
{
    //使用mmap函数建立共享映射区
    //void *mmap(void *addr, size_t length, int prot, int flags,
    //              int fd, off_t offset);
    int fd = open("./test.log", O_RDWR);
    if(fd<0)
    {
        perror("open error");
        return -1;
    }

    int len = lseek(fd, 0, SEEK_END);

    //建立共享映射区
    void * addr = mmap(NULL, len, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    if(addr==MAP_FAILED)
    {
        perror("mmap error");
        return -1;
    }

    char buf[64];
    memset(buf, 0x00, sizeof(buf));
    memcpy(buf, addr, 10);
    printf("buf=[%s]\n", buf);

    return 0;
}

mmap注意事项

  • 创建映射区的过程中，隐含着一次对映射文件的读操作，将文件内容读取到映射区。

  • 当MAP_SHARED时，映射区的权限必须<=文件打开的权限。

  • 映射区的释放与文件的关闭无关，只要映射创建成功，文件可以立即关闭。

  • 当映射文件大小为0时，不能创建映射区。

  • munmap传入的地址一定是mmap的返回地址。坚决杜绝指针++操作。

  • 文件偏移量必须为0或者4k的整数倍。

  • mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。

别写Bug了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python中的进程间通信
12-20
文章目录Python中的进程间通信1 进程间通信1.1 概念1.2进程间通信方法各种进程间通信1. 基于信号量（Semaphore）的IPC2 基于信号（Signal）的IPC3.基于管道（Pipe）的IPC4. 基于有名管道（fifo）的IPC5.基于消息队列...
进程间通信有哪几种方式
刚学会HelloWorld的XXX的博客
03-02 2839
无名管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。 高级管道(popen)：将另一个程序当做一个新的进程在当前程序进程中启动，则它算是当前程序的子进程，这种方式我们成为高级管道方式。 有名管道 (named pipe) ： 有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。 消息队列( m...
进程间通信详解
向未来❀去探索 的博客
06-26 8925
进程间通信详解(命名管道，匿名管道，共享内存)
【Linux】进程间通信
热门推荐
Edward_Asia的博客
05-02 1万+
目录 1. 进程间通信 1.1. 进程间通信的目的 1.2. 如何实现进程间通信 2. 管道通信 2.1. 匿名管道 2.1.1 创建匿名管道 2.1.2 . 深入理解匿名管道 2.2. 命名管道 2.2.1. 创建命名管道 3. system V 标准进程间通信 3.1. 共享内存 3.1.1. 实现原理 3.1.2. 代码实现 3.2. 消息队列(了解) 3.2.1 实现原理 3.3. 信号量(了解) 3.3.1. 实现原理 1. 进程间通信 1.1.
进程间通信之共享内存
weixin_57023347的博客
09-16 1万+
接博客：进程间通信之管道 一.共享内存实现进程间通信的原理 共享内存实际是操作系统在实际物理内存中开辟的一段内存。 共享内存实现进程间通信，是操作系统在实际物理内存开辟一块空间，一个进程在自己的页表中，将该空间和进程地址空间上的共享区的一块地址空间形成映射关系。另外一进程在页表上，将同一块物理空间和该进程地址空间上的共享区的一块地址空间形成映射关系。 当一个进程往该空间写入内容时，另外一进程访问该空间，会得到写入的值，即实现了进程间的通信。 ...
Linux-进程间通信
AI_ELF的博客
08-23 6171
数据传输：一个进程需要将它的数据发送给另一个进程资源共享：多个进程之间共享同样的资源。通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
C++进程间通信 详解2
GIS摆渡人
05-24 3430
文章目录 一、概述二、进程间通信概念及方法1. 管道的概念2. pipe3. 管道的读写行为4. 管道缓冲区大小5. 管道优劣6. FIFO7. 共享存储映射8. mmap函数9. munmap函数10. mmap九问11. mmap父子进程间通信12. 匿名映射13. mmap无血缘关系进程间通信 3. 练习 一、概述 二、进程间通信概念及方法 Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和...
Linux进程间通信
北川_的博客
04-04 4968
目录进程间通信介绍进程间通信的概念进程间通信目的进程间通信分类进程间通信的本质 进程间通信介绍 进程间通信的概念 进程间通信又称IPC(Inter-Process Communication)，指多个进程之间相互通信，交换信息。 进程间通信目的 数据传输： 一个进程需要将它的数据发送给另一个进程 资源共享： 多个进程之间共享同样的资源。 通知事件： 一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。 进程控制： 有些进程希望完全控制另一个进程的执行（如Deb
进程间通信之管道
weixin_57023347的博客
09-14 3350
目录 前言 进程间通信的目的: 一.管道 1.1 匿名管道 1.1.1 匿名管道的使用场景 1.1.2 匿名管道实现通信的原理 1.1.3 怎么创建管道 1.1.4 怎么实现进程间通信 1.1.5 管道通信额四种情况 1.1.6 匿名管道的特征 1.2 命名管道 1.2.1 命名管道的原理 1.2.2 创...
Linux —— 进程间通信
M的博客
07-23 5576
进程间通信方式的介绍：管道通信、system V通信......
C# 进程间通信 共享内存
03-25
共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。...1、进程间通信 2、共享内存 3、托管方式与非托管共享内存
C# 使用管道Pipe在进程间通信
03-25
进程间通信的一种方式，Pipes：管道，分为无名管道：在父子进程间交换数据；有名管道：可在不同主机间交换数据，分为服务器方和客户方，在Win9X下只支持有名管道客户。 1、进程间通信 2、管道Pipe通信
Linux部署安装
最新发布
凌北辰的博客
05-10 367
因为在RPM安装过程中经常需要解决依赖关系，而有些依赖关系并不会有准确的依赖安装包提示信息，YUM是RPM包管理工具,可以很好解决RPM包安装过程中会遇到的依赖关系问题。YUM安装软件时至少需要一个YUM源，YUM源就像一个存放了好多RPM包的仓库，用户可以使用ftp、http等方式访问YUM源。Linux上大部分软件都是开源软件（apache、tomcat、PHP、MySQL等）YUM可以从多个 源中搜索软件及软件安装所依赖的安装包，并自动安装相应的依赖软件。软件组安装-字符界面安装图形化。
Linux字符设备驱动(一) - 框架
滴水藏海
05-06 1034
字符设备驱动的注册
Linux生成密钥对并配置免密访问
u014516208的博客
05-07 303
先生成私钥，再生成公钥。
Linux——综合实验
Xinan_____的博客
05-07 799
> MASTER_HOST='wangA.wld.com', //主节。赋予root用户replication slave 权限。编辑一个数据库连接脚本，测试数据库是否能正常连接。创建共享目录/share_nfs。编辑nfs配置文件 设置允许ip。2.7.1.存在53端口占用。编辑自动挂载父目录配置文件。编辑自动挂载父目录配置文件。编辑自动挂载子目录配置文件。创建一个用户用来做主从同步。从节点同步主节点二进制文件。创建一个只做nfs的用户。解决办法：停止其他端口。为我们的应用创建一个库。
Linux 第二十三章
一怀明月的博客
05-08 915
回顾文件 fopen() fwrite fputs >文件名 追加重定向 认识系统接口 open linux中常见的函数传参数 umask write read 语言和系统的区别 文件描述符
Python进程间通信
02-20
Python进程间通信是指在多个Python进程之间进行交换和共享的机制。Python提供了多种进程间通信的方式，包括管道、消息队列、共享内存和套接字等。 1. 管道（Pipe）：管道是一种半双工的通信方式，可以在父进程和子...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值