进程间通信——管道

最新推荐文章于 2024-03-19 20:21:29 发布

皮蛋的小世界

最新推荐文章于 2024-03-19 20:21:29 发布

阅读量602

点赞数 11

分类专栏： Linux 文章标签： linux

本文链接：https://blog.csdn.net/weixin_65660590/article/details/136127712

版权

Linux 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

文章目录

进程间通信的介绍
- 进程间通信的目的
- 进程间通信的本质
匿名管道
- 创建管道
- 匿名管道的特征
命名管道
- 小结

进程间通信的介绍

进程间通信简称IPC（Interprocess communication），进程间通信就是在不同进程之间传播或交换信息。

进程间通信的目的

数据传输： 一个进程需要将它的数据发送给另一个进程。
资源共享： 多个进程之间共享同样的资源。
通知事件： 一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件，比如进程终止时需要通知其父进程。
进程控制： 有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

进程间通信的本质

进程间通信的本质就是，让不同的进程看到同一份资源。

由于各个运行进程之间具有独立性，这个独立性主要体现在数据层面，而代码逻辑层面可以私有也可以公有（例如父子进程），因此各个进程之间要实现通信是非常困难的。

各个进程之间若想实现通信，一定要借助第三方资源，这些进程就可以通过向这个第三方资源写入或是读取数据，进而实现进程之间的通信，这个第三方资源实际上就是操作系统提供的一段内存区域。

操作系统提供的这一段内存区域被我们称为：公共资源。

公共资源有了，还必须让要通信的进程都看到这一份公共资源，此时要通信的进程将有了通信的前提。之后就是进程通信，也就是访问这块公共资源的数据。

之所以有不同的通信方式，是因为公共资源的种类不能，如果公共资源是一块内存，那么通信方式就叫做共享内存，如果公共资源是一个文件，也就是struct file结构体，那么就叫做管道。

首先我们来回忆一下文件系统
在这里插入图片描述
父进程打开一个文件，操作系统在内存上创建一个struct file结构体对象，里面包含文件的各种属性，以及对磁盘文件的操作方法。

每个struct file对象中还有一个内核缓冲区，这个缓冲区中可以存放数据。

当子进程创建的时候，父进程的文件描述符表会被子进程继承下去，所以此时子进程在相同的fd处也指向父进程打开的文件。

文件描述符表一个进程维护一个，但是struct file结构体对象在内存中只有一个，由操作系统维护。

此时，父子进程将看到了同一份公共资源，也就是操作系统在内存中维护的struct file对象，并且父子进程也都和这份资源建立了连接。

此时父子进程通信的基础有了，它们就可以通信了。
父进程向文件中写内容，写完后继续干自己的事，并不破坏父进程的独立性。
子进程向文件中读内容，读完后继续干自己的事，并不破坏子进程的独立性。

这样一读一写，父子进程将完成了一次进程间通信。

而我们又知道，对文件进行IO操作时，由于需要访问硬盘，所以速度非常的慢，而且我们发现，父子间进行通信，磁盘中文件的内容并不重要，重要的是父进程写了什么，子进程又读到了什么。

此时操作系统为了提高效率，就关闭了内存中struct file和硬盘中文件进行IO的通道。
父进程写数据写到了struct file的内核缓冲区中。
子进程读数据从struct file的内核缓冲区中读取。

此时，父子间通信仍然正常进行，并且效率还非常的高，而且还没有影响进程的独立性。而这种不进行IO的文件叫做内存级文件。

这种由文件系统提供公共资源的进程间通信，就叫做管道。
在这里插入图片描述
进程A和B就通过管道建立起了连接，并且可以进程进程之间的通信。而管道又分为匿名管道和命名管道。

匿名管道

匿名管道：顾名思义，就是没有名字的文件(struct file)。匿名管道只能用于父子进程间通信，或者由一个父进程创建的兄弟进程之间进行通信。

现在我们知道了匿名管道就是没有名字的文件，通过管道进行通信时，只需要通信双方打开同一个文件就可以。

我们通过系统调用open打开文件的时候，会指定打开方式，是读还是写。

当父进程以写方式打开一个文件的时候，创建的子进程会继承父进程的一切。
此时子进程也是以写的方式打开的这个文件。

既然是通信，势必有一方在写，一方在读，而现在父子双方都是以写的方式打开，它们怎么进行通信呢？

父进程以读和写的方式打开同一份文件两次。
在这里插入图片描述
此时的管道文件分为写端和读端，并且写端和读端各会返回一个文件描述符fd。所以父进程的文件描述符表中，和管道文件有关的文件描述符fd就有两个。

这样一来，创建子进程后，父子进程都可以对管道进行读和写，它们就可以进行通信了，上面的问题就解决了。

之所以命名为管道，那么就有和管道类似的性质。在生活中，我们对水管，它的流向只能是单向的，管道也一样，通过管道建立的通信只能进行单向数据通信。

是因为通过内存级文件通信的方式具有这种特点，才命名的管道。
而不是先命名管道才设计的内存级文件通信方式。
在这里插入图片描述

为了防止父进程对管道进行误读，以及子进程对管道进行误写，破坏通信规则。
将父进程的读端关闭，将子进程的写端关闭，使用系统调用close(fd)。

按照上面的操作，父进程进行读的操作，子进程读取父进程传输过来的数据

创建管道

建立管道的系统调用pipe
上面都是理论上的，具体到代码中是如何建立管道的呢？既然是操作系统中的文件系统提供的公共资源，当然是用系统调用来建立管道了。
在这里插入图片描述

形参：int pipefd[2]是一个输出型参数，是一个数组，该数组只有两个元素，下标分别为0和1。
下标为0的元素表示的是管道读端的文件描述符fd。
下标为1的元素表示的是管道写端的文件描述符fd。

使用系统调用pipe，直接就会得到两个fd，并且放入父进程的文件描述符表中，不用打开内存级文件两次。

返回值：int类型的整数，对管道创建情况进行反馈。
返回0，表示管道创建成功。
返回-1，表示管道创建失败，并且会将错误码自动写入errno中。

#include <iostream>
#include <cerrno>
#include <cstring>
#include <unistd.h>

int main()
{
    int fds[2];
    int ret = pipe(fds);
    if(ret < 0)
    {
        std::cerr<<errno<<":"<<strerror(errno)<<std::endl;
    }
    std::cout<<"fds[0]: "<<fds[0]<<std::endl;
    std::cout<<"fds[1]: "<<fds[1]<<std::endl;

    return 0;
}

在这里插入图片描述
可以看到，创建管道后返回的两个fd值，果然是3和4，因为0,1,2分别被stdin，stdout，stderr占用。

知道了如何使用系统调用创建管道以后，接下来就创建子进程，然后关闭不需要的端口了，原理已经清楚，直接看代码。

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

#define MAX 1024

using namespace std;
//子写 父读
int main()
{
    int status = 0;
    //1、建立管道
    int pipefd[2] = {0};
    int n = pipe(pipefd);
    //pipe函数成功返回0
    assert(n == 0);
    (void)n;  //没有用到n，防止编译器告警
    cout << "pipefd[0]" << pipefd[0] << " " << "pipefd[1]" << pipefd[1] << endl;
    //2、创建子进程
    pid_t id = fork();
    if(id < 0)
    {
        perror("fork");
        return 1;
    }
    if(id == 0)  //子进程
    {
        close(pipefd[0]);
        int cnt = 10;
        while(cnt)
        { 
            char message[MAX]; 
            snprintf(message, sizeof(message), "hello, I am child,pid: %d, cnt : %d",getpid(), cnt);
            cnt--;
            write(pipefd[1], message, strlen(message));
            sleep(1);
        }

        exit(0);
    }
    //父进程  返回子进程id
    close(pipefd[1]);
    char buffer[MAX]; 
    while(1)
    {
        ssize_t n  = read(pipefd[0], buffer, sizeof(buffer) - 1);
        if(n > 0)
        {
            buffer[n] = '\0';
            cout << "child say:" << buffer << "to father" << endl;
        }
        else break;
    }

    pid_t rid = waitpid(id, &status, 0);
    if(rid == id)
    {
        cout << "wait sucess" << endl;
    }
    return 0; 
}