进程间通信

已于 2023-04-01 16:42:19 修改
阅读量143 收藏
点赞数
文章标签： 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中进程间通信的概念，包括管道、信号、共享映射区和本地套接字等通信方式。特别地，文章深入讨论了管道的使用，包括其匿名性、单向数据流和限制，并提供了创建和使用管道的示例代码。此外，还提到了FIFO（命名管道）和内存映射区（mmap）作为进程间通信的手段，以及它们的使用场景和注意事项。
摘要由CSDN通过智能技术生成

进程间通信的概念：

在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创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。

未被发现的天才
关注
4、进程间通信（pipe、fifo、共享内存（shm、mmap函数实现代码））（linux系统编程）
伍粟的博客
04-25 553
进程间通信： 任何一个进程的全局变量在另一个进程中都看不到， 所以进程和进程之间不能相互访问，要交换数据必须通过内核， 在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区， 进程2再从内核缓冲区把数据读走， 内核提供的这种机制称为进程间通信（IPC，InterProcess Communication）。 进程间通信的方式: 在进程间完成数据传递需要借助操作系统提供特殊的方法， 进程间的七大通信方式 signal、file、 pipe（管道（Pipe）及有名管道（named pipe）：就是pi
C# 进程间通信 共享内存
03-25
共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。...1、进程间通信 2、共享内存 3、托管方式与非托管共享内存
进程间通信有哪几种方式
刚学会HelloWorld的XXX的博客
03-02 2871
无名管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。 高级管道(popen)：将另一个程序当做一个新的进程在当前程序进程中启动，则它算是当前程序的子进程，这种方式我们成为高级管道方式。 有名管道 (named pipe) ： 有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。 消息队列( m...
Linux文件I/O编程
baboon_chen
09-17 843
​ I/O可以分为 高级I/O 和 低级I/O，高级I/O 通常也称为 带缓冲的I/O，比如 ANSI C库提供的标准I/O库。低级I/O通常也称为不带缓冲的I/O，它是Linux提供的系统调用，如：open、read、write等。带缓冲的I/O在系统调用前采用一定的策略，速度慢，但比不带缓冲的I/O安全，如：fopen、fread、fwrite等。 Linux下对文件进行输入输出操作（I/O操...
34-进程间通信——FIFO（命名管道）
网络安全
09-26 606
1. 何为命名管道   在前面的学习中我们知道管道(pipe)只能用于“有血缘关系”的进程间。    它们之间最大的区别就是FIFO提供一个路径名与之关联，在文件系统中有一个索引块，以文件路径的形式存在（在磁盘中没有数据块，所有数据都存放在内核），而这个文件路径是FIFO被称为命名管道的重要原因。    FIFO与管道类似，其本质上也是内核的一块缓冲区，FIFO也有一个写入端和读取端，FIFO中...
Linux进程之-进程间通信
qq_42041303的博客
04-11 345
目录 1、pipe进行父子进程间通信 2、pipe进行兄弟进程间通信 3、fifo进行无血缘关系的进程间通信 4、mmap函数：如何使用、创建匿名映射区、进行有血缘关系的进程间通信和进行无血缘关系的进程间通信 概念 IPC: InterProcess Communication 进程间通信，通过内核提供的缓冲区进行数据交换的机制。 IPC通信的方式： pipe 管道 --最简单 fifo 有名管道 mmap 文件映射共享IO --速度最快 本地socket --最稳定 信号 --携带
进程间通信详解
向未来❀去探索 的博客
06-26 1万+
进程间通信详解(命名管道，匿名管道，共享内存)
Python中的进程间通信
12-20
Python中的进程间通信（IPC，Inter-Process Communication）是指不同进程之间交换信息的方式。在多进程编程中，由于进程间的独立性，它们不能直接访问彼此的内存空间，因此需要通过特定的方法来协调和同步进程间的...
C#使用SendMessage实现进程间通信的方法
09-03
在C#编程中，进程间通信（IPC，Inter-Process Communication）是一种允许不同进程之间交换数据的技术。在本文中，我们将探讨如何使用Windows API中的`SendMessage`函数在两个C#进程中实现这一通信方式。 `...
Linux进程间通信–使用信号
01-11
但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，...
UNIX Linux实验教程 4实验四Linux进程间通信.doc
09-26
UNIX/Linux 进程间通信实验教程 UNIX/Linux 操作系统提供了一组系统调用作为用户使用其进程间通信机制的接口。进程间通信是指在多任务计算机系统中，每个进程都具有自己独立的全局变量和局部变量，子进程几乎完全...
进程之间的通信方式
m0_58907318的博客
10-29 2881
每日总结与复盘
进程间的通信方式（六种）
热门推荐
m0_72838865的博客
08-16 1万+
直到进程 A 访问完共享内存，才会执行 V 操作，使得信号量恢复为 0，接着就会唤醒阻塞中的线程 B，使得进程 B 可以访问共享内存，最后完成共享内存的访问后，执行 V 操作，使信号量恢复到初始值 1。而且，数据会被分为一个一个的数据单元，称为消息体，消息发送方和接收方约定好消息体的数据类型，不像管道是无格式的字节流类型，这样的好处是可以边发送边接收，而不需要等待完整的数据。接着，当进程 A 生产完数据后，执行了 V 操作，就会使得信号量变为 0，于是就会唤醒阻塞在 P 操作的进程 B；...
【Linux】操作系统初步理解与Linux指令入门
2303_80828380的博客
10-27 687
Ubuntu 22.04 server 64bit环境
【ShuQiHere】Linux 桌面环境：选择与定制指南 ️✨
ShuQIHere的博客
10-26 1234
Linux 桌面环境（Desktop Environment，简称 DE）是用户与操作系统交互的图形界面。它不仅决定了系统的外观和感觉，还影响着用户的工作效率和使用体验。无论你是新手还是资深用户，选择和定制适合自己的桌面环境都是提升 Linux 使用体验的重要一步。本文将带你全面了解 Linux 桌面环境的基本概念、常见类型、选择技巧以及定制方法。🚀
‌Linux tac命令‌
最新发布
weixin_37788102的博客
10-30 212
tac命令实际上是cat命令的一个变体，尽管它的功能相对简单，但在某些情况下非常有用。例如，当需要查看文件的最后一行（通常是标题或总结）时，使用tac命令可以避免滚动查看整个文件。此外，tac命令对于处理大型文件或需要快速定位文件末尾内容的情况非常有用‌。‌Linux tac命令‌是一个用于逆序显示文件内容的工具，其名称来源于“cat”的反向拼写。tac命令的基本功能是将文件的内容从最后一行开始输出，直到第一行结束，这与cat命令的功能相反，cat命令是从第一行开始输出直到最后一行。tac命令的基本用法。
VMware各版本下载的镜像站(含windows和linux)
王佐儿z的博客
10-27 334
转载地址。
[linux]项目部署
.
10-26 914
3、编写Shell脚本(拉取、编译、打包、启动)4、为用户授予执行shell脚本的权限。通过shell脚本自动部署项目的流程。2、在Linux中安装maven。1、在Linux中安装Git。5、执行shell脚本。
Linux进程间通信详解
"该资源为一份关于Linux进程间通信的PDF文档，由孙天泽于2006.3年撰写，主要介绍了Linux系统中的进程通信机制，适用于嵌入式Linux应用程序开发的学习与实践。文档内容包括Linux进程、内核开发、驱动程序开发以及应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值