Linux进程间通信【匿名管道】

精选原创

Yohifo 2023-07-05 11:32:13 博主文章分类：Linux学习之旅 ©著作权

©著作权归作者所有：来自51CTO博客作者Yohifo的原创作品，请联系作者获取转载授权，否则将追究法律责任

✨个人主页： [北海] 🎉所属专栏： Linux学习之旅 🎃操作环境： CentOS 7.6 阿里云远程服务器**

🌇前言

进程间通信简称为 IPC（Interprocess communication），是两个不同进程间进行任务协同的必要基础。进行通信时，首先需要确保不同进程之间构建联系，其次再根据不同的使用场景选择不同的通信解决方案，本文主要介绍的通信解决方案为 ==匿名管道==

🏙️正文

1、进程间通信相关概念

在正式学习 匿名管道 之前，需要简单了解一下通信的相关概念

1.1、目的

进程间通信主要有以下四个目的：

==数据传输== ：不同进程间进行数据传输，比如此时我写的博客数据正在源源不断的上传至 CSDN 服务器中
==资源共享== ：多个进程之间需要共享资源，假设每个用户都是独立的进程，那么整个 C 站就是一个被共享的资源，用户之前可以共享其技术资源
==事件通知==：一个进程向其他进程发送消息，通知处理相关事宜，比如子进程终止时，需要通知父进程，回收其资源
==进程控制==：有些进程需要起到管理者的作用，于是需要与被管理进程之间构建通信关系，进程任务下达及进程控制，并对进程状态进行实时监视

其实进程间通信的最终目的就是 打破各个独立进程之前的壁垒，进行任务协同

就好比大航海时期的冒险家们，克服困难、勇于开拓，打破了不同大陆间的隔离状态，最终将世界连为一个 “整体”，人类文明迎来了高速发展时期

让世界连成一整体，开始了全球化发展

有利于讲文明传播到世界各地，促进了世界各地的交流

帮助不发达的地方引进新的文明成果

进程间具有独立性，这是原则 让进程间可以更好的协同工作，这是目的

因此进程间通信的本质就是 ==让不同的进程看到同一份 “资源”==

其中的 ==资源== 由 OS 直接或间接提供

无论后续的哪种进程间通信的解决方案，都要解决以下两个问题：

想办法让不同的进程看到同一份资源
让其中一方写入，另一方读取，完成通信；至于通信的目的及后续工作，需要结合具体场景分析

1.2、发展

进程间通信的发展可以简单概况为以下三个时期：

管道时期（古老的通信方式）
System V 标准时期（本地化进程间通信）
POSIX 标准时期（网络中进程间通信）

管道可以说是十分古老且简单了，后来新出的 System V 标准丰富了进程间通信的方式，但奈何无法满足网络中的进程间通信需求，于是诞生了更好的 POSIX 标准

管道适合深入学习，探究进程间通信时的原理及执行流程

System V 标准如今比较少用了，但其通信速度极快的共享内存还是值得深入学习的

POSIX 是 Unix 系统的一个设计标准，很多类 Unix 系统也在支持兼容这个标准，如 Linux , POSIX 标准具有跨平台性，就连 Windows 也对其进行了支持，后续学习同步与互斥时，所使用的信号量等都是出自 POSIX 标准，这是进程间通信的学习重点

POSIX 标准支持网络中通信，比如 套接字（socket） 就在此标准中

1.3、分类

根据不同发展时期的标准，可以将进程间通信的解决方案划分为以下几种：

管道：

匿名管道

命名管道

System V 标准：

System V 消息队列

System V 共享内存

System V 信号量

POSIX 标准：

POSIX 消息队列

POSIX 共享内存

POSIX 信号量

POSIX 互斥量（互斥锁）

POSIX 条件变量

POSIX 读写锁

显然，随着时代进步，技术也在不断迭代发展，新标准在替代旧标准时，也必然新增时代特色需求，比如上世纪末的网络；如今人工智能的迅猛发展也给传统从业者敲响了警钟，只有在自我发展中寻求变革，才能 hold 住新时代发展的浪潮

2、什么是管道？

管道是 Unix 系统 IPC （进程间通信）中 最古老 的方式，其历史最早可追溯至 1964年10月11日

管道的历史出自《UNIX PIPES 管道原稿》 --- 陈皓

在命令行中输入 | 即可使用管道

创建两个睡眠时间较长的 后台进程

sleep 10000 | sleep 20000 &

注：& 表示令当前进程变为后台进程

可以看出，两个 sleep 进程的 PPID 一致，同时 PID 连续，因此这两个进程是兄弟关系

管道分为 匿名管道 和 命名管道，两者绝大部分原理、特点都一致，本文主要介绍 匿名管道，同时适用于 命名管道 的知识点统一称为管道

Linux 中一切皆文件，所以管道本质上就是一个文件

3、管道的工作原理

管道的工作原理其实很简单：打开一个文件，让两个进程分别享有读端与写端 fd，对文件进行操作即可

命名管道和匿名管道基本原理都差不多，但命名管道更强大，能实现两个毫不相干的进程间通信

具体在 OS 中的体现：在文件的结构体 files_struct 中，存在一个特殊的成员 struct file *fd_array[]，这是一个指针数组，其中存储的是指向不同文件的指针

//Linux内核源码（部分）
struct files_struct {
  /*
   * read mostly part
   */
	atomic_t count;
	struct fdtable __rcu *fdt;
	struct fdtable fdtab;
  /*
   * written part on a separate cache line in SMP
   */
	spinlock_t file_lock ____cacheline_aligned_in_smp;
	int next_fd;
	unsigned long close_on_exec_init[1];
	unsigned long open_fds_init[1];
	struct file __rcu * fd_array[NR_OPEN_DEFAULT];	//文件指针数组
};

此时父进程可以打开匿名管道文件，fork 子进程后，子进程继承原有的文件系统关系，与父进程共享同一份文件资源，然后父子进程分别关闭读端与写端，实现匿名管道的单向关系，即可正常进行通信

具体流程：

父进程创建匿名管道，同时以读、写的方式打开匿名管道，此时会分配两个 fd

fork 创建子进程，子进程拥有自己的进程系统信息，同时会继承原父进程中的文件系统信息，此时子进程和父进程可以看到同一份资源：匿名管道 pipe

因为子进程继承了原有关系，因此此时父子进程对于 pipe 都有读写权限，需要确定数据流向，关闭不必要的 fd，比如父进程写、子进程读，或者父进程读、子进程写都可以

==注意：==

fork 创建子进程后，子进程会继承原父进程中的文件系统信息，这也就是父子进程都会同时向屏幕打印信息的原理，因为此时它们操作的是同一个文件！
父进程需要以读写的方式打开匿名管道 pipe，这样子进程在继承时，才不会发生权限丢失
创建出的匿名管道文件 pipe 虽然属于文件系统，但它是一个特殊文件，一个由 OS 提供的纯纯的内存文件，不需要将数据冲刷至磁盘中，只需要承担进程间通信任务即可
管道是一种半双工、单流向的通信方式，因为 pipe 只有一个缓冲区，所以这种方式才被叫做管道通信

4、匿名管道的创建与使用

4.1、pipe 函数

匿名管道是通过 pipe 函数创建的，其函数原型如下所示

#include <unistd.h>

int pipe(int pipefd[2]);

关于 pipefd 数组

数组元素	含义
`pipefd[0]`	表示匿名管道的 `读端`
`pipefd[1]`	表示匿名管道的 `写端`

巧记：

pipefd[0] -> 0 -> 嘴巴 -> 读书 -> 读端
pipefd[1] -> 1 -> 钢笔 -> 写字 -> 写端

关于返回值：创建匿名管道成功，返回 0，失败返回 -1，并设置错误码

实际在使用此函数时，需要先创建好大小为 2 的 pipefd 数组，然后将其传入函数，成功创建匿名管道后，pipefd 数组中存储的就是 匿名管道的读端和写端 fd

4.2、实例代码演示

下面通过一个简单的程序，演示 匿名管道函数 pipe 的使用

使用匿名管道步骤

创建匿名管道
创建子进程
关闭不需要的 fd
开始通信

#include <iostream>
#include <cassert>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

int main()
{
    // 1、创建匿名管道
    int pipefd[2]; // 数组
    int ret = pipe(pipefd);
    assert(ret == 0);
    (void)ret; // 防止 release 模式中报警告

    // 2、创建子进程
    pid_t id = fork();
    if (id == 0)
    {
        // 子进程内
        close(pipefd[1]); // 3、子进程关闭写端

        // 4、开始通信
        char buff[64]; // 缓冲区
        while (true)
        {
            int n = read(pipefd[0], buff, sizeof(buff) - 1);    //注意预留一个位置存储 '\0'
            buff[n] = '\0';

            if (n >= 5 && n < 64)
            {
                // 读取到了信息
                cout << "子进程成功读取到信息：" << buff << endl;
            }
            else
            {
                // 未读取到信息
                if (n == 0)
                    cout << "子进程没有读取到信息，通信结束！" << endl;
                // 读取异常（消息过短）
                else
                    cout << "子进程读取数据量为：" << n << " 消息过短，通信结束！" << endl;
                break;
            }
        }

        close(pipefd[0]); // 关闭剩下的读端
        exit(0);          // 子进程退出
    }

    // 父进程内
    close(pipefd[0]); // 3、父进程关闭读端

    char buff[64];

    // 4、开始通信
    srand((size_t)time(NULL)); // 随机数种子
    while (true)
    {
        int n = rand() % 26;
        for (int i = 0; i < n; i++)
            buff[i] = (rand() % 26) + 'A'; // 形成随机消息
        buff[n] = '\0';                    // 结束标志

        cout << "=============================" << endl;
        cout << "父进程想对子进程说: " << buff << endl;
        write(pipefd[1], buff, strlen(buff)); // 写入数据

        if (n < 5)
            break; // 消息过短时，不写入

        sleep(1);
    }

    close(pipefd[1]); // 关闭剩下的写端

    // 父进程等待子进程结束
    int status = 0;
    waitpid(id, &status, 0);

    // 通过 status 判断子进程运行情况
    if ((status & 0x7F))
    {
        printf("子进程异常退出，core dump: %d   退出信号：%d\n", (status >> 7) & 1, (status & 0x7F));
    }
    else
    {
        printf("子进程正常退出，退出码：%d\n", (status >> 8) & 0xFF);
    }

    return 0;
}

站在 文件描述符 的角度理解上述代码：

站在 内核（管道本质） 的角度理解上述代码：

所以，看待 管道 ，就如同看待 文件 一样！管道 的使用和 文件 一致，迎合 ==Linux一切皆文件思想==

4.3、管道读写规则

管道是一种 半双工、单向流 的通信方式，因此在成功创建匿名管道后，需要两个待通信的进程都能获得同一个 pipefd 数组

这就是匿名管道比较特殊的地方了：匿名管道只支持具有血缘关系的进程通信，如父子进程、兄弟进程等，因为只有继承了，才能共享到 同一个 pipefd 数组

当通信双方都获得 pipefd 数组后，需要根据情况关闭不需要的 fd，确保 单流向 的原则

注：命名管道可以支持不具有血缘关系进程间通信

关于匿名管道还有一个函数：pipe2 （了解），比 pipe 函数多一个参数2 flags，可以使匿名管道在发生特殊情况时，作出不同的动作，当 flags 为 0 时，pipe2 等价于 pipe

管道的读写规则：

PIPE_BUF 为管道大小，Linux 中为 4096 字节

当要写入的数据量不大于 PIPE_BUF 时，Linux 将保证写入的原子性
当要写入的数据量大于 PIPE_BUF 时，Linux 将不再保证写入的原子性

原子性：不存在中间状态，确保数据的安全性

5、管道的特点

管道主要有以下几个特点：

1.单向通信，管道是半双工的一种特殊情况

管道就像单行道，只允许数据单向流通，即通知，如果想要实现两个进程间相互进行通信，需要创建两条管道，管道1：父进程写，子进程读；管道2：子进程写，父进程读

2.管道的本质是文件，因为 fd 的生命周期随进程而终止，所以管道的生命周期也是随着进程而结束的

当进程终止运行时，管道资源会被 OS 回收

3.匿名管道常用来进行具有 “血缘” 关系的进程，进行进程间通信（常用于父子进程间通信）

pipe 打开管道，并不清楚管道的名字等信息，这种管道称为 匿名管道，因此 匿名管道 只能用于有血缘关系的进程 IPC，因为 需要通过 fork 继承匿名管道信息

4.在管道中，写入 与 读取 的次数并不是严格匹配的，此时读写次数没有强相关关系，管道是面向字节流读写的

面向字节流读写又称为 流式服务：数据没有明确的分割，不分一定的报文段；与之相对应的是 数据报服务：数据有明确的分割，拿数据按报文段拿
不论写端写入了多少数据，只要写端停止写入，读端都可以将数据读取

5.具有一定的协同能力，让 读端 和 写端 能够按照一定的步骤进行通信（自带同步机制）

当读端进行从管道中读取数据时，如果没有数据，则会阻塞，等待写端写入数据；如果读端正在读取，那么写端将会阻塞等待读端，因此 管道自带同步与互斥机制

可以简单总结为：

管道是半双工通信

管道生命随进程而终止

匿名管道只支持具有血缘关系的进程间通信，而命名管道无所谓

管道提供的是流式数据传输服务

管道自带同步与互斥机制

6、管道的四种特殊场景

管道还存在四种特殊场景：管道为空、管道为满、写端关闭、读端关闭，四种场景对应四种不同的特殊情况，都可以通过代码进行演示

==注意：== 当前大部分场景中，子进程为读端，父进程为写端

6.1、场景一

父进程不写，此时管道为空，子进程尝试读取

////伪代码段////
// 父进程不写（空），子进程读

//子进程（尝试读取）
int cnt = 1;
while (true)
{
    char ch;
    read(pipefd[0], &ch, 1);
    cout << "已读取 " << cnt++ << " 字节的数据" << endl;
}

//父进程（不写）
while (true) {}

结果：因为管道为空，因此子进程无法读取，即读端阻塞

只有当写端写入数据后，读端才能正常读取

6.2、场景二

父进程不断写入，直到管道写满，子进程不读取

////伪代码段////
//父进程写（满），子进程不读

//子进程（不读）
while (true) {}

//父进程（不断写入）
int cnt = 1; // 计数器
while (true)
{
    char ch = 'x';
    write(pipefd[1], &ch, 1); // 写入数据
    cout << "已写入 " << cnt++ << " 字节的数据" << endl;
}

结果：在一段时间后，管道被写满，写端无法写入数据，进入阻塞状态

只有当读端尝试将管道中的数据读走一部分后，写端才能继续写入

形象化理解管道为空：垃圾桶为空时，你不会去倒垃圾（读端阻塞），因为没有垃圾，需要等有垃圾了（写入数据）才去倒 管道为满：垃圾桶中的垃圾装满时，无法再继续扔垃圾（写端阻塞），需要等把垃圾倒了（读取数据），才能继续扔垃圾

6.3、场景三

在通信的过程中，关闭写端，只保留读端

////伪代码段////
//写端写入一段信息后，就关闭

//子进程正常读取，并且对读取到的数据量进行判断
char buff[64];
while(true)
{
    int n = read(pipefd[0], buff, sizeof(buff) - 1);
    buff[n] = '\0';

    if(n == 0)
        cout << "写端已关闭，读取数据量为: " << n << " 字节" << endl;
    else
        cout << "成功读取到信息: " << buff << endl;

    sleep(1);
}

//父进程只写入一次数据，然后关闭写端
char buff[] = "Hello pipe!";
write(pipefd[1], buff, strlen(buff)); // 写入数据

close(pipefd[1]); // 关闭剩下的写端

结果：关闭写端后，读端会将匿名管道中的数据读取完后，再读，会读到 0，表示已读到文件末尾

如何理解？

因为管道是单流向通信，写端都关闭了，证明不会再有数据写入，因此当读端把剩余数据都读取后，每次都是读取 0 字节数据，表明此时已经读到了结尾，读端也可以结束读取了

6.4、场景四

在通信过程中，关闭读端，只保留写端

注：这里将角色变换一下，方便父进程捕捉到子进程的退出信号

切换：父进程 -> 读端，子进程 -> 写端

////伪代码段////
//读端读取一段时间后，就关闭

//子进程不断写入
while (true)
{
    char buff[] = "Hello pipe!";
    write(pipefd[1], buff, strlen(buff)); // 写入数据
    sleep(1);
}

//父进程在读取五次信息后，就终止读取，关闭读端
char buff[64];
int cnt = 1;
while (true)
{
    int n = read(pipefd[0], buff, sizeof(buff) - 1);
    buff[n] = '\0';

    if (n == 0)
        cout << "写端已关闭，读取数据量为: " << n << " 字节" << endl;
    else
        cout << "成功读取到信息: " << buff << endl;

    // 读取五次后，关闭读端
    if (cnt++ == 5)
        break;
}

close(pipefd[0]);

// 父进程等待子进程结束
int status = 0;
waitpid(id, &status, 0);
printf("子进程异常退出，core dump: %d   退出信号：%d\n", (status >> 7) & 1, (status & 0x7F));

结果：OS 不允许任何浪费资源的行为存在，如果关闭了读端，那么证明写端写了也没有，即没有存在的意义，于是 OS 会发出 13 号信号，终止写端进程

通过指令查看信号表

kill -l

以上就是管道的四种特殊场景，不仅适用于匿名管道，同时也适用于命名管道

7、匿名管道的大小

既然管道能被写满，那么管道的大小究竟是多少？

一、通过 man 手册查询相关信息

man 7 pipe

接着输入 /pipe capacity 即可搜索出管道的大小

文档解释：在 Linux 2.6.11 之前，管道大小为一个系统页的大小（比如在 i386 平台中，管道大小为 4096 字节，即 4kb），从 Linux 2.6.11 开始，管道大小的容量统一为 65536 字节，即 64kb

因为在 Linux 2.6.11 版本中，对管道进行更新，采取了新的解决方案

原文链接：Circular pipes

可以通过指令查看当前系统的内核版本号

uname -a

二、通过指令查看当前系统资源的限制情况

ulimit -a

当前系统中，限制单条管道大小为 512 * 8 = 4096 字节

可以前往 /usr/src/kernels/内核版本信息/include/linux/pipe_fs_i.h 这个文件中，查看当前系统的 管道条目数，比如我当前的系统中，管道条目数为 16，因此管道的大小上限为 4096 * 16 = 65536 字节

此时可以猜测：新的管道解决方案中，为所有的管道分配了一块定额空间，可用的 16 条管道中，可以根据自己的需要，获取大小，极大提高了效率

三、通过程序验证

这个前面就已经验证过了，不断往管道中写数据，直到管道被写满

每次写入 1 字节的数据，可以看到最终写了 65536 字节的数据

总之，从 Linux 2.6.11 版本开始，管道大小上限为 64kb

8、匿名管道实操-进程控制

匿名管道作为 IPC 的其中一种解决方案，那么肯定有它的实战价值

场景：父进程创建了一批子进程，并通过多条匿名管道与它们链接，父进程选择某个子进程，并通过匿名管道与子进程通信，并下达指定的任务让其执行

8.1、逻辑设计

首先创建一批子进程及匿名管道 -> 子进程（读端）阻塞，等待写端写入数据 -> 选择相应的进程，并对其写入任务编号（数据）-> 子进程拿到数据后，执行相应任务

8.2、具体功能实现

下面来看看具体功能实现（部分细节可能未展示，详细实现可以看源码）

1、创建一批进程及管道

创建一批进程及管道

首先需要先创建一个包含进程信息的类，最主要的就是子进程的写端 fd，这样父进程才能通过此 fd 进行数据写入
循环创建管道、子进程，进行相应的管道链接操作，然后子进程进入任务等待状态，父进程将创建好的子进程信息注册
假设子进程获取了任务代号，那么应该根据任务代号，去执行相应的任务，否则阻塞等待

==注意：== 因为是创建子进程，所以存在关系重复继承的情况，此时应该统计当前子进程的写端 fd，在创建下一个进程时，关闭无关的 fd

具体体现为：每次都把写端 fd 存储起来，在确定关系前 “清理” 干净

关于上述操作的危害，需要在编写完进程等待函数后，才能演示其作用

#define NAME_SIZE 64
// 封装一个包含各种必备信息的类

class ProcInfo
{
public:
    ProcInfo(pid_t id = pid_t(), int fd = int())
        : _childID(id), _wfd(fd), _num(++_count)
    {
        char buff[NAME_SIZE];
        snprintf(buff, sizeof buff, "Process %d [%d:%d]", _num, _childID, _wfd);
        _name = string(buff);
    }

    ~ProcInfo()
    {
        _childID = _wfd = 0;
    }

    pid_t _childID;  // pid
    int _wfd;        // 写端 fd
    string _name;    // 进程名
    int _num;   //编号
    static int _count; // 计数
};

int ProcInfo::_count = 0; // 静态成员初始化

void CreateProcessAndPipe(vector<ProcInfo> &PP, int ppNum = 3)
{
    vector<int> fds;    //存储继承中不需要的写端 fd
    for(int i = 0; i < ppNum; i++)
    {
        //首先创建管道
        int pipefd[2];
        int ret = pipe(pipefd);
        assert(ret != -1);
        (void)ret;

        //然后创建子进程
        int id = fork();
        assert(id != -1);
        (void)id;

        if(id == 0)
        {
            //子进程内

            //需要先关闭之前子进程遗留的写端fd
            for(auto e : fds)
                close(e);

            close(pipefd[1]);   //子进程关闭写端
            waitCommand(pipefd[0]);  //子进程等待命令

            close(pipefd[0]);
            exit(0);
        }

        //父进程内
        close(pipefd[0]);   //父进程关闭读端
        PP.push_back(ProcInfo(id, pipefd[1]));
        fds.push_back(pipefd[1]);
    }
}

2、任务类创建及任务等待

子进程在创建完成后，需要进入一个 等待阶段 -> 读端阻塞，同时当子进程读取到相应的指令时，需要执行相应任务，这里将封装成了一个类，并通过对象调用函数

ctrlProc.cc 中

void waitCommand(int rfd)
{
    while(true)
    {
        //读端尝试读取信息
        int command = 0; 
        int n = read(rfd, &command, sizeof(command));
        if(n != 0)
        {
            TaskPools().Execute(command);
        }
        else
        {
            cout << "当前子进程读取任务失败，已退出!" << endl;
            break;
        }
    }
}

Task.hpp 中

#pragma once

#include <iostream>
#include <vector>
#include <unistd.h>

using namespace std;

void PrintLOG()
{
  cout << "PID: " << getpid() << " 正在执行打印日志的任务…" << endl;
}

void InsertSQL()
{
  cout << "PID: " << getpid() << " 正在执行数据库插入的任务…" << endl;
}

void NetRequst()
{
  cout << "PID: " << getpid() << " 正在执行网络请求的任务…" << endl;
}

typedef void(*func_t)();

//任务池
class TaskPools
{
public:
    TaskPools()
    {
    	//装载任务
        _vft.push_back(PrintLOG);
        _vft.push_back(InsertSQL);
        _vft.push_back(NetRequst);
    }

    ~TaskPools()
    {}

    void Execute(int num)
    {
        //根据编号，执行任务
        if(num < 0 || num > _vft.size())
            cout << "没有这个任务" << endl;
        else
            _vft[num]();
    }

private:
    vector<func_t> _vft;    //可用任务表
};

3、子进程控制

当所有子进程都完成注册后（统计至 PP 中），可以让用户输入下标选择程序、输入任务编号选择任务、或者输入程序退出

==注意：== 因为当前子进程编号从 1 开始，所以在进行下标访问时，需要 -1 避免越界

void showTask()
{
    cout << "**************************" << endl;
    cout << "* 0.日志打印  1.数据插入 *" << endl;
    cout << "* 2.网络请求  3.退出程序 *" << endl;
    cout << "**************************" << endl;
}

void CtrlProcess(vector<ProcInfo> &PP)
{
    while (true)
    {
        // 展示当前可用的进程
        int index = 0;
        do
        {
            cout << "当前可选择进程：";
            for (int i = 1; i <= PP.size(); i++)
                cout << i << " ";
            cout << endl;

            cout << "请选择进程: ";
            cin >> index;
        } while (index < 1 || index > PP.size());

        int taskNum = 0;
        do
        {
            showTask(); // 展示可选任务
            cout << "请选择任务: ";
            cin >> taskNum;
        } while (taskNum < 0 || taskNum > 3);

        // 分配任务
        if(taskNum == 3)
            break;

        cout << "已选择： " << PP[index - 1]._num << " 号进程 | " << PP[index - 1]._name << endl;
        write(PP[index - 1]._wfd, &taskNum, sizeof(taskNum));
        sleep(1);   //执行完任务后，睡一会
    }
}

此时已经可以把任务跑起来了

现在就是万事俱备，只欠回收

4、子进程回收

子进程回收十分简单，因为已经在 PP 中存储了各个子进程的 PID，只需要遍历等待回收即可

void WaitProcess(vector<ProcInfo> &PP)
{
    // 遍历回收就好了
    for (auto e : PP)
    {
        close(e._wfd);  //关闭写端，读端读取到 0 自动结束阻塞
        int status = 0;
        waitpid(e._childID, &status, 0);

        // 通过 status 判断子进程运行情况
        if ((status & 0x7F))
        {
            printf("子进程异常退出，core dump: %d   退出信号：%d\n", (status >> 7) & 1, (status & 0x7F));
        }
        else
        {
            printf("子进程 %s 正常退出，退出码：%d\n", e._name.c_str(), (status >> 8) & 0xFF);
        }
    }

    cout << "所有子进程都已回收" << endl;
}

此时可以验证一下之前的 存在多个写端的问题

首先正常跑（有解决方案的前提下）

然后删除原来的解决方案：vector<int> fds

所以 关闭不必要的 fd 还是很重要的，尤其是在这种涉及继承的场景中

8.3、效果演示

下面通过一个动图看看整个程序的运行情况

8.4、注意事项

总体来说，在使用这个小程序时，以下关键点还是值得多注意的

注册子进程信息时，存储的是写端 fd，目的是为了通过此 fd 向对应的子进程写数据，即使用不同的匿名管道
创建管道后，需要关闭父、子进程中不必要的 fd
需要特别注意父进程写端 fd 被多次继承的问题，避免因写端没有关干净，而导致读端持续阻塞
关闭读端对应的写端后，读端会读到 0，可以借助此特性结束子进程的运行
在选择进程 / 任务时，要做好越界检查
等待子进程退出时，需要先关闭写端，子进程才会退出，然后才能正常等待

8.5、完整源码

整个程序的完成源码如下所示：

ctrlProc.cc

#include <iostream>
#include <vector>
#include <string>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include "Task.hpp" //任务所需头文件

using namespace std;

#define NAME_SIZE 64

// 封装一个包含各种必备信息的类
class ProcInfo
{
public:
    ProcInfo(pid_t id = pid_t(), int fd = int())
        : _childID(id), _wfd(fd), _num(++_count)
    {
        char buff[NAME_SIZE];
        snprintf(buff, sizeof buff, "Process %d [%d:%d]", _num, _childID, _wfd);
        _name = string(buff);
    }

    ~ProcInfo()
    {
        _childID = _wfd = 0;
    }

    pid_t _childID;    // pid
    int _wfd;          // 写端 fd
    string _name;      // 进程名
    int _num;          // 编号
    static int _count; // 计数
};

int ProcInfo::_count = 0; // 静态成员初始化

void waitCommand(int rfd)
{
    while (true)
    {
        // 读端尝试读取信息
        int command = 0;
        int n = read(rfd, &command, sizeof(command));
        if (n != 0)
        {
            TaskPools().Execute(command);
        }
        else
        {
            cout << "当前子进程读取任务失败，已退出!" << endl;
            break;
        }
    }
}

void CreateProcessAndPipe(vector<ProcInfo> &PP, int ppNum = 3)
{
    vector<int> fds; // 存储继承中不需要的写端 fd
    for (int i = 0; i < ppNum; i++)
    {
        // 首先创建管道
        int pipefd[2];
        int ret = pipe(pipefd);
        assert(ret != -1);
        (void)ret;

        // 然后创建子进程
        int id = fork();
        assert(id != -1);
        (void)id;

        if (id == 0)
        {
            // 子进程内

            // 需要先关闭之前子进程遗留的写端fd
            for (auto e : fds)
                close(e);

            close(pipefd[1]);       // 子进程关闭写端
            waitCommand(pipefd[0]); // 子进程等待命令

            close(pipefd[0]);
            exit(0);
        }

        // 父进程内
        close(pipefd[0]); // 父进程关闭读端
        PP.push_back(ProcInfo(id, pipefd[1]));
        fds.push_back(pipefd[1]);
    }
}

void showTask()
{
    cout << "**************************" << endl;
    cout << "* 0.日志打印  1.数据插入 *" << endl;
    cout << "* 2.网络请求  3.退出程序 *" << endl;
    cout << "**************************" << endl;
}

void CtrlProcess(vector<ProcInfo> &PP)
{
    while (true)
    {
        // 展示当前可用的进程
        int index = 0;
        do
        {
            cout << "当前可选择进程：";
            for (int i = 1; i <= PP.size(); i++)
                cout << i << " ";
            cout << endl;

            cout << "请选择进程: ";
            cin >> index;
        } while (index < 1 || index > PP.size());

        int taskNum = 0;
        do
        {
            showTask(); // 展示可选任务
            cout << "请选择任务: ";
            cin >> taskNum;
        } while (taskNum < 0 || taskNum > 3);

        // 分配任务
        if (taskNum == 3)
            break;

        cout << "已选择： " << PP[index - 1]._num << " 号进程 | " << PP[index - 1]._name << endl;
        write(PP[index - 1]._wfd, &taskNum, sizeof(taskNum));
        sleep(1); // 执行完任务后，睡一会
    }
}

void WaitProcess(vector<ProcInfo> &PP)
{
    // 遍历回收就好了
    for (auto e : PP)
    {
        close(e._wfd);  //关闭写端，读端读取到 0 自动结束阻塞
        int status = 0;
        waitpid(e._childID, &status, 0);

        // 通过 status 判断子进程运行情况
        if ((status & 0x7F))
        {
            printf("子进程异常退出，core dump: %d   退出信号：%d\n", (status >> 7) & 1, (status & 0x7F));
        }
        else
        {
            printf("子进程 %s 正常退出，退出码：%d\n", e._name.c_str(), (status >> 8) & 0xFF);
        }
    }

    cout << "所有子进程都已回收" << endl;
}

int main()
{
    // 1、创建一批进程及匿名管道
    vector<ProcInfo> PP;
    CreateProcessAndPipe(PP);

    // 2、进程控制
    CtrlProcess(PP);

    // 3、进程回收
    WaitProcess(PP);

    return 0;
}

Task.hpp

#pragma once

#include <iostream>
#include <vector>
#include <unistd.h>

using namespace std;

void PrintLOG()
{
  cout << "PID: " << getpid() << " 正在执行打印日志的任务…" << endl;
}

void InsertSQL()
{
  cout << "PID: " << getpid() << " 正在执行数据库插入的任务…" << endl;
}

void NetRequst()
{
  cout << "PID: " << getpid() << " 正在执行网络请求的任务…" << endl;
}

typedef void(*func_t)();

//任务池
class TaskPools
{
public:
    TaskPools()
    {
        _vft.push_back(PrintLOG);
        _vft.push_back(InsertSQL);
        _vft.push_back(NetRequst);
    }

    ~TaskPools()
    {}

    void Execute(int num)
    {
        //根据编号，执行任务
        if(num < 0 || num > _vft.size())
            cout << "没有这个任务" << endl;
        else
            _vft[num]();
    }

private:
    vector<func_t> _vft;    //可用任务表
};

Makefile

ctrlProc:ctrlProc.cc
	g++ -o $@ $^ -std=c++11

.PHONY:clean
clean:
	rm -r ctrlProc

🌆总结

以上就是本次关于 Linux 进程间通信之匿名管道的全部内容了，在本文中，我们首先学习了什么是 IPC，以及 IPC 的发展历史及分类；然后从 管道 中的 匿名管道 入手，介绍了 管道 的各种特性、场景及 匿名管道 的使用；最后通过一个简单的 匿名管道 进程控制程序，将 匿名管道 IPC 这种方法的知识整体运用了一遍，第一次接触这种多进程程序，还是值得一写的

星辰大海

<center>相关文章推荐</center>

<center>Linux基础IO【软硬链接与动静态库】</center>

<center>Linux基础IO【深入理解文件系统】</center>

<center>Linux【模拟实现C语言文件流】</center>

<center>Linux基础IO【重定向及缓冲区理解】</center>

<center>Linux基础IO【文件理解与操作】</center>

<center>===============</center>

<center>Linux【模拟实现简易版bash】</center>

<center>Linux进程控制【进程程序替换】</center>

<center>Linux进程控制【创建、终止、等待】</center>