进程间通信1（面试常考）

业界资讯 2022-04-28 13:52:29 阅读次数: 0

进程间通信（面试常考）

一、进程间通信

1.1 什么是进程间通信

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

1.2 进程间通信的方式

  在进程间完成数据传递需要借助操作系统提供特殊的方法，如：文件、管道、信号、共享内存、消息队列、套接字、命名管道等。随着计算机的蓬勃发展，一些方法由于自身设计缺陷被淘汰或者弃用。现今常用的进程间通信方式有：

  • 管道 (使用最简单)

  • 信号 (开销最小)

  • 共享映射区 (无血缘关系)

  • 本地套接字 (最稳定)

二、管道-pipe

2.1 管道的概念

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

在这里插入图片描述

有如下特质：

  • 管道的本质是一块内核缓冲区

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

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

  • 当两个进程都终结的时候，管道也自动消失。
    管道的读端和写端默认都是阻塞的。

2.2 管道的原理

  • 管道的实质是内核缓冲区，内部使用环形队列实现。

  • 默认缓冲区大小为4K，可以使用ulimit -a命令获取大小。

  • 实际操作过程中缓冲区会根据数据压力做适当调整。

2.3 管道的局限性

  • 数据一旦被读走，便不在管道中存在，不可反复读取。

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

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

2.4 创建管道-pipe函数

  • 函数作用:
    创建一个管道

  • 函数原型:
    int pipe(int fd[2]);

  • 函数参数:
    若函数调用成功，fd[0]存放管道的读端，fd[1]存放管道的写端

  • 返回值:
    成功返回0；
    失败返回-1，并设置errno值。

  函数调用成功返回读端和写端的文件描述符，其中fd[0]是读端， fd[1]是写端，向管道读写数据是通过使用这两个文件描述符进行的，读写管道的实质是操作内核缓冲区。

  管道创建成功以后，创建该管道的进程（父进程）同时掌握着管道的读端和写端。如何实现父子进程间通信呢？

2.5 父子进程使用管道通信

  一个进程在由pipe()创建管道后，一般再fork一个子进程，然后通过管道实现父子进程间的通信（因此也不难推出，只要两个进程中存在血缘关系，这里的血缘关系指的是具有共同的祖先，都可以采用管道方式来进行通信）。父子进程间具有相同的文件描述符，且指向同一个管道pipe，其他没有关系的进程不能获得pipe(）产生的两个文件描述符，也就不能利用同一个管道进行通信。

第一步：父进程创建管道

在这里插入图片描述
第二步：父进程fork出子进程

在这里插入图片描述
第三步：父进程关闭fd[0]，子进程关闭fd[1]

在这里插入图片描述
创建步骤总结：

  • 父进程调用pipe函数创建管道，得到两个文件描述符fd[0]和fd[1]，分别指向管道的读端和写端。

  • 父进程调用fork创建子进程，那么子进程也有两个文件描述符指向同一管道。

  • 父进程关闭管道读端，子进程关闭管道写端。父进程可以向管道中写入数据，子进程将管道中的数据读出，这样就实现了父子进程间通信。

2.6 使用管道进行进程通信-练习

一个进程能否使用管道完成读写操作呢？

使用管道完成父子进程间通信？

#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);//验证read函数没有数据阻塞
                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));//read函数如果没有数据就会阻塞，不管子进程和父进程谁先执行，无关系
                //写的话，写满了阻塞
                printf("read over, n==[%d], buf==[%s]\n", n, buf);

        }

        return 0;
}

在这里插入图片描述

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

使用execlp函数和dup2函数

直接执行ps aux会将结果写到标准输出也就是/dev/tty，我们需要写道管道，也就从管道读，就需要重定向两次：

这是使用ps aux | grep bash命令的：

在这里插入图片描述
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;
}

在这里插入图片描述

兄弟进程间通信, 实现ps aux | grep bash

使用execlp函数和dup2函数

父进程要调用waitpid函数完成对子进程的回收

2.7 管道的读写行为

读操作

  • 有数据
    read正常读，返回读出的字节数

  • 无数据
    写端全部关闭：read解除阻塞，返回0, 相当于读文件读到了尾部
    写端没有全部关闭：read阻塞

写操作

  • 读端全部关闭
    管道破裂，进程终止, 内核给当前进程发SIGPIPE信号

  • 读端没全部关闭
    缓冲区写满了：write阻塞
    缓冲区没有满：继续write

2.8 如何设置管道为非阻塞

  默认情况下，管道的读写两端都是阻塞的，若要设置读或者写端为非阻塞，则可参考下列三个步骤进行：

  • 第1步： int flags = fcntl(fd[0], F_GETFL, 0);

  • 第2步： flag |= O_NONBLOCK;

  • 第3步： fcntl(fd[0], F_SETFL, flags);

若是读端设置为非阻塞：

  • 写端没有关闭，管道中没有数据可读，则read返回-1；

  • 写端没有关闭，管道中有数据可读，则read返回实际读到的字节数

  • 写端已经关闭，管道中有数据可读，则read返回实际读到的字节数

  • 写端已经关闭，管道中没有数据可读，则read返回0

2.9 如何查看管道缓冲区大小

命令
ulimit -a

函数
long fpathconf(int fd, int name);

printf("pipe size==[%ld]\n", fpathconf(fd[0], _PC_PIPE_BUF));

printf("pipe size==[%ld]\n", fpathconf(fd[1], _PC_PIPE_BUF));

三、命名管道-FIFO

  FIFO常被称为命名管道，以区分管道(pipe)。管道(pipe)只能用于“有血缘关系”的进程间通信。但通过FIFO，不相关的进程也能交换数据。

  FIFO是Linux基础文件类型中的一种（文件类型为p，可通过ls -l查看文件类型）。但FIFO文件在磁盘上没有数据块，文件大小为0，仅仅用来标识内核中一条通道。进程可以打开这个文件进行read/write，实际上是在读写内核缓冲区，这样就实现了进程间通信。

3.1 创建管道

方式1-使用命令 mkfifo
命令格式： mkfifo 管道名
例如：mkfifo myfifo

方式2-使用函数
int mkfifo(const char *pathname, mode_t mode);
参数说明和返回值可以查看man 3 mkfifo

  当创建了一个FIFO，就可以使用open函数打开它，常见的文件I/O函数都可用于FIFO。如：close、read、write、unlink等。

  FIFO严格遵循先进先出（first in first out），对FIFO的读总是从开始处返回数据，对它们的写则把数据添加到末尾。它们不支持诸如lseek()等文件定位操作。

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

使用FIFO·完成两个进程通信的示意图：
在这里插入图片描述

思路：

进程A：

① 创建一个fifo文件：myfifo

② 调用open函数打开myfifo文件

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

④ 调用close函数关闭myfifo文件

进程B：

① 调用open函数打开myfifo文件

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

③ 打印显示读取的内容

④ 调用close函数关闭myfifo文件

注意：myfifo文件是在进程A中创建的，如果先启动进程B会报错。思考一下如何解决这个问题呢？？？

//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;
        }
        write(fd, "hello world", strlen("hello world"));
        sleep(10);
        //关闭文件
        close(fd);

        return 0;
}

//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文件
        char buf[64];
        memset(buf, 0x00, sizeof(buf));
        int n = read(fd, buf, sizeof(buf));
        printf("n==[%d], buf==[%s]\n", n, buf);
        //关闭文件
        close(fd);
        getchar();
        return 0;
}

在这里插入图片描述
在这里插入图片描述

四、内存映射区

4.1 存储映射区介绍

  存储映射I/O (Memory-mapped I/O)使一个磁盘文件与存储空间中的一个缓冲区相映射。从缓冲区中取数据，就相当于读文件中的相应字节；将数据写入缓冲区，则会将数据写入文件。这样，就可在不使用read和write函数的情况下，使用地址（指针）完成I/O操作。

  使用存储映射这种方法，首先应通知内核，将一个指定文件映射到存储区域中。这个映射工作可以通过mmap函数来实现。

在这里插入图片描述

4.2 mmap函数

  • 函数作用:
    建立存储映射区

  • 函数原型
    void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

  • 函数返回值：
    成功：返回创建的映射区首地址；
    失败：MAP_FAILED宏

  • 参数：
    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, 表示从文件头开始映射。

使用mmap函数建立匿名映射：
mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_SHARED , -1, 0);
匿名映射：只能用于血缘关系的进程间通信
MAP_SHARED必须与MAP_SHARED一起使用，而且fd指定为-1

//使用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);
        //void * addr = mmap(NULL, len, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
        if(addr==MAP_FAILED)
        {
    
    
                perror("mmap error");
                return -1;
        }
        close(fd);

        //创建子进程
        pid_t pid = fork();
        if(pid<0)
        {
    
    
                perror("fork error");
                return -1;
        }
        else if(pid>0)
        {
    
    
                memcpy(addr, "hello world", strlen("hello world"));
                wait(NULL);//保证父进程后退出
        }
        else if(pid==0)
        {
    
    
                sleep(1);
                char *p = (char *)addr;
                printf("[%s]", p);
        }

        return 0;
}

这里使用MAP_SHARED能够对映射区的修改反映到文件中去，也就是能修改文件，而MAP_PRIVATE不行。
在这里插入图片描述

  • memcpy函数
    原型：extern void *memcpy(void *dest, void *src, unsigned int count);
    功能：由src所指内存区域复制count个字节到dest所指内存区域。
    说明：src和dest所指内存区域不能重叠，函数返回指向dest的指针。

4.3 munmap函数

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

  • 函数原型:
    int munmap(void *addr, size_t length);

  • 返回值：
    成功：返回0
    失败：返回-1，设置errno值

  • 函数参数:
    addr：调用mmap函数成功返回的映射区首地址
    length：映射区大小（mmap函数的第二个参数）

4.4 mmap注意事项

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

  • 当MAP_SHARED时，要求：映射区的权限应 <=文件打开的权限(出于对映射区的保护)。而MAP_PRIVATE则无所谓，因为mmap中的权限是对内存的限制。

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

  • 特别注意，当映射文件大小为0时，不能创建映射区。所以，用于映射的文件必须要有实际大小；mmap使用时常常会出现总线错误，通常是由于共享文件存储空间大小引起的。

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

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

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

4.5 有关mmap函数的使用总结

  • 第一个参数写成NULL

  • 第二个参数要映射的文件大小 > 0

  • 第三个参数：PROT_READ 、PROT_WRITE

  • 第四个参数：MAP_SHARED 或者 MAP_PRIVATE

  • 第五个参数：打开的文件对应的文件描述符

  • 第六个参数：4k的整数倍

总结

期待大家和我交流，留言或者私信，一起学习，一起进步！

猜你喜欢

转载自blog.csdn.net/CltCj/article/details/123686100
今日推荐
AI小程序有哪些？AI小程序哪个好用？微信小程序AI写作叫什么？免费的ai小程序推荐 ai写作小程序推荐
灵办AI工具(科研学术,代码编程,学习辅导,图书报告)功能介绍
Linux内核源码分析（非常详细）零基础入门到精通，收藏这一篇就够了
【C++篇】启航——初识C++（上篇）
数据飞轮崛起：数据中台真的过时了吗？
828华为云征文——使用Flexus云服务器X实例CentOS镜像下创建MySQL服务器教程
阿里巴巴出品的6款AI神器，你用过几个？
【机器学习】多模态AI——融合多种数据源的智能系统
HashiCorp 创始人向 Zig 软件基金会捐赠 30 万美元
1-8 月我国软件业务收入 85492 亿元，同比增长 11.2%
零基础入门鸿蒙开发 HarmonyOS NEXT星河版开发学习
豆包MarsCode帮我2小时完成Go语言系统从开发、测试到部署全流程最佳实践，云IDE迁移PHP企业级项目最佳实践
周排行
Ubuntu+apache2+php5+mysql+phpmyadmin的php环境搭建
基于YOLOv3+Kalman-Filter实现Multi-target tracking
解释C++实例化类的指针类型中的new
苹果手机页面不兼容问题——mui
Python基础语法
javascript学习笔记一【预解释】
python内置函数 map
【Git】使用webstorm操作git
this与super关键字（一）
python list 使用技巧
每日归档
更多
2024-10-04(63)
2024-10-03(2)
2024-10-02(60)
2024-10-01(0)
2024-09-30(0)
2024-09-29(0)
2024-09-28(4)
2024-09-27(60)
2024-09-26(0)
2024-09-25(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022