Linux操作系统进程间通信

一、进程间通信的背景

进程是具有独立性的，即使是父子进程之间，父进程的数据子进程能够看得见，但这是在没有发生写时拷贝的前提下，一旦发生了写时拷贝，父子进程之间的数据是不能相互看见的，这是因为进程是具有独立性的。正是因为进程具有独立性，所以进程之间想要交互数据，成本是非常高的。所以我们要有支持进程间通信的方法。除此之外，如果我们想要多进程协同完成一件事情，也需要实现进程间通信。

进程间通信的方式一般有管道通信、System V标准的进程间通信、POSIX标准的进程间通信。进程之间实现通信的的前提是我们要让不同的进程看到同一份资源。这个同一份资源可以是文件、内存块等等，只有不同的进程看到了同一份资源，才可以实现一个进程向资源内写入内容，其它进程可以从资源内读取内容获取信息，从而完成通信。不同的资源种类，决定了不同的进程间通信方式。

二、管道

1.管道的原理

管道本质上就是一个内存级文件。当我们创建一个进程的时候，操作系统会维护一个task_struct结构以及files_struct结构，files_struct结构里有一个结构体数组struct file*fd_array[]，其中保存着该进程打开的文件的地址。我们用该进程创建并打开一个管道文件，然后创建一个子进程。当子进程被创建成功的时候，会将父进程的task_struct结构和files_struct结构拷贝下来。因此，父进程打开的文件子进程也可以找得到。此时的父进程打开的文件就是能够被子进程看到的同一份资源，我们可以在管道文件中实现进程间的通信，这就是管道的原理。

2.管道的特点

1. 管道是用来传输数据的文件，这份文件可以被多个进程同时看到。
2. 管道是半双工的，数据只能从一个方向流动。即进行通信的两个进程只能由一个进程向管道写入内容，由另一个进程从管道中读取内容。不能两个进程同时向管道写入和读取内容。
3. 一般而言，进程退出，管道释放，所以管道的生命周期是随进程的。
4. 匿名管道的限制是只能用于具有共同祖先的进程（即具有亲缘关系的进程）之间进行通信；如果我们想让两个没有亲缘关系的进程之间进行通信，需要用到命名管道。
5. 管道是自带同步机制的，它会自带访问控制，当管道满了的时候，写端进程不能再写入数据，必须阻塞式等待读端进程读取走数据才可以接着写入；当管道空了的时候，读端进程不能再读取数据，必须阻塞式等待写端进程写入数据才可以接着读取。
6. 管道是面向字节流的。首先管道是一块固定大小的缓冲区，管道中先写入的字符一定是先被读取的。其次，管道内的内容是没有格式边界的，需要我们使用管道的用户来规定内容的边界。比如说如果我们没有规定格式边界，写端进程一直在写入数据但读端进程暂时就是不读取，等到写端进程写入完毕以后，读端进程就会一次性地从头到尾将数据全部读取。同样的如果我们没有规定格式边界，但是写端进程写入之后读端进程也在读取数据，那么写端进程就会向管道内一个字节一个字节地写入数据，读端进程就会从管道内一个字节一个字节地读取数据。所以我们可以规定管道的格式边界，比如我们控制写端进程在写入的时候，调用write接口的时候规定每次写入的大小是sizeof()多少，比如每次写入sizeof(int)大小的数据，那么读端进程每次也会读取sizeof(int)大小的数据。

3.匿名管道

使用匿名管道进行进程间通信限制在具有亲缘关系的进程之间，所以使用匿名管道的步骤一般分为下面几步：

1. 首先由父进程创建匿名管道文件，该文件的读端和写端文件都会被打开。
2. 父进程创建子进程，子进程继承了父进程的匿名管道文件。
3. 根据需求，在父子进程中分别将读端文件和写端文件关闭，以此来满足只有一个进程进行写入操作，另一个进程进行读取操作。

创建匿名管道需要用到的系统调用接口是pipe接口：该接口会默认打开读端文件和写端文件，需要我们将数组pipefd传递进去用来获取读端文件和写端文件的文件描述符。pipefd[0]是读端文件的文件描述符，pipefd[1]是写端文件的文件描述符。如果匿名管道文件创建成功则返回值为0，创建失败则返回值为-1.

我们以一个简单的例子来演示一下匿名管道的使用方式：

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

#define NUM 1024

using namespace std;

int main()
{
   
    // 1.创建匿名管道
    int pipefd[2]; // 用来获取匿名管道的读写端文件描述符
    // 如果匿名管道文件创建失败
    if (pipe(pipefd) != 0)
    {
   
        cerr << "pipe error" << endl;
        return 1;
    }

    // 2.创建子进程
    pid_t id = fork();
    if (id == 0)
    {
   
        // 子进程
        // 我们让子进程进行读取操作，所以就要关闭写端文件
        close(pipefd[1]);

        // 子进程开始执行读取操作
        while (true)
        {
   
            char buf[NUM];
            memset(buf, 0, sizeof(buf));
            ssize_t readRes = read(pipefd[0], buf, sizeof(buf) - 1);
            // 读取成功，打印读取到的内容
            if (readRes > 0)
            {
   
                buf[readRes] = '\0';
                cout << buf << endl;
            }
            // 父进程关闭写端文件，停止读取
            else if (readRes == 0)
            {
   
                cout << "父进程退出了，子进程也可以退出了" << endl;
                break;
            }
            // 读取失败
            else
            {
   
                cerr << "read error" << endl;
                return 4;
            }
        }

        // 子进程读取完毕，关闭读端文件
        close(pipefd[0]);
        cout << "子进程读取完毕，可以退出了" << endl;
        exit(0);
    }
    else if (id > 0)
    {
   
        // 父进程
        // 我们让父进程进行写入操作，所以就要关闭读端文件
        close(pipefd[0]);

        // 父进程开始执行写入操作
        string msg = "你好子进程，我是父进程！";
        int cnt = 0;
        while (cnt < 5)
        {
   
            ssize_t writeRes = write(pipefd[1], msg.c_str(), msg.size());
            // 写入失败
            if (writeRes < 0)
            {
   
                cerr << "write error" << endl;
                return 3;
            }
            cnt++;
            sleep(1);
        }

        // 父进程写入完毕，关闭写端文件
        close(pipefd[1]);
        cout << "父进程写入完毕，可以退出了" << endl;
    }
    else
    {
   
        cerr << "fork error" << endl;
        return 2;
    }

    // 父进程最后需要回收子进程
    pid_t waitRes = waitpid(id, nullptr, 0);
    // 等待失败
    if (waitRes != id)
    {
   
        cerr << "wait error" << endl;
        return 5;
    }
    return 0;
}

运行程序结果如图：

1. 当父进程关闭了写端文件的时候，子进程是如何得知父进程关闭了的？
由于文件引用计数的存在，所以子进程可以得知父进程是否关闭了写端文件。

2. 上面的代码中，父进程在写入操作时每次写入都会sleep上1s，而子进程并没有设置sleep，为什么子进程读取内容的时候也会跟着sleep上1s呢？
当管道内部没有数据的时候，读端进程就必须阻塞等待；当管道内部数据被写满的时候，写端进程也必须阻塞等待。

除了父进程向子进程传递简单的信息，我们还可以利用这个方法来让父进程控制子进程执行任务，例如下面这份代码：我们写一个任务集合，将不同的任务加载进vector类型的任务集合中（由于没有具体的业务，所以就简单地输出一下语句当作是一个任务），父进程随机生成任务编码，将这个任务编码传递给子进程，子进程获取到这个任务编码以后再到任务集合中执行相应的任务。

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

// 3
using namespace std;

typedef void (*functor)();

vector<functor> functors; // 任务集合

unordered_map<uint32_t, string> info; // 任务信息

void func1()
{
   
    cout << "这是任务一，执行该任务的进程pid:[" << getpid() << "],执行时间:[" << time(nullptr) << "]" << endl;
}

void func2()
{
   
    cout << "这是任务二，执行该任务的进程pid:[" << getpid() << "],执行时间:[" << time(nullptr) << "]" << endl;
}

void func3()
{
   
    cout << "这是任务三，执行该任务的进程pid:[" << getpid() << "],执行时间:[" << time(nullptr) << "]" << endl;
}

void loadFunctor()
{
   
    info.insert({
   functors.size(), "任务一"});
    functors.push_back(func1);

    info.insert({
   functors.size(), "任务二"});
    functors.push_back(func2);

    info.insert({
   functors.size(), "任务三"});
    functors.push_back(func3);
}

int main()
{
   
    // 加载任务
    loadFunctor();
    // 创建管道
    int pipefd[2];
    // 创建管道失败
    if (pipe(pipefd) != 0)
    {
   
        cerr << "pipe error" << endl;
        return 1;
    }

    // 创建子进程
    pid_t id = fork();
    if (id == 0)
    {
   
        // 子进程
        // 子进程获取任务指令并执行，关闭写端文件
        close(pipefd[1]);