＜Linux＞进程间通信--管道_计算机管道如何实现通讯-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_63246064/article/details/129360027

前言😃😃😃

进程间通信的方式

管道 - Linux原生提供

2SystemV - 多线程单机通信

posix - 多线程网络通信

这里我们主要是介绍一下管道

一、生活和计算机中的管道😜

生活中的管道特点

都是有出口和入口的

都是单向传输内容的(例如：纯净水管道和污水管道不可能同时传输纯净水和污水对吧)

管道中传输的都是资源(例如：运输天然气等等)

计算机中的管道：

和生活中的管道特点类似，同样都是有出口和入口的都是单向传输的，不过计算机中传输的资源是“数据”。

总结：管道是一种进程间单向通信的方式。

二、管道实现进程间通信的原理😏

先说核心概念：管道通信背后是通过进程之间的共享内存进行通信的，记住这句话好了，我们开始解说原理。

在说原理之前，我们需要明确一点 --- 进程之间是具有很强的独立性的；

我们需要知道在创建一个进程时，操作系统会为这个进程创建一个task_struct结构体和files_struct文件结构体，task_struct来记录这个进程的信息，files_struct文件结构体来记录这个进程打开的文件信息。这里我们需要知道的是：files_struct是用来记录一个进程打开文件的信息的，OK知道了这一点

在files_struct中有一个fd_array[]数组 -- 用来存放进程打开的文件fd(文件描述符的)，在这里我们可以举个实例：我们打开的每一个进程都会自动打开stdin/stdout/stderr -- 分别是标准输入/标准输出/标准错误，对应的在fd_array[0], fd_array[1], fd_array[2]。分别放的是stdin/stdout/stderr的文件描述符

这里我们需要知道的是:files_struct中有一个fd_array[]数组 -- 用来存放进程打开的文件fd

有了以上的认识之后，我们就可以描述一下一个进程是如何去访问文件的了：

例如进程A想访问一个打开的文件B，A通过它自己的task_struct结构体找到指向files_struct结构体的成员指针，再通过files_struct找到其中的fd_array[]成员数组，访问这个数组从而就可以找到这个进程打开的文件B的文件描述符fd了，通过fd就可以访问这个文件B了。

好了现在又有了一个阶段性的认识，知道了进程是如何访问文件的了，这里很重要的一点，那些是进程相关的数据结构、那些是文件相关的数据结构？

为什么要做这个区分？因为进程之间是有很强的独立性的，有关进程的数据结构之间是基本不可能有什么交集的，就更不要说通过进程的相关数据结构进行进程间通信了。而文件相关的数据结构就不一样，文件要被访问是会被加载在内存中的，而这些被加载到内存中的文件是可以被任何进程访问的！！！这是一个十分关键的一点，管道通信的理解关键就在于此。也就是说我们可以通过两个进程访问一个文件来间接的实现进程间通信。

以上对管道通信的原理做出的相对清楚的解释，还有一点小小细节，为了保证管道的特点，需要多加以下一下规则：

一个进程只用写方式打开文件，另一个文件只用读方式打开文件(保证单向)

三、demo代码😍

如下写了一个使用管道通信的例子：

大致的流程是：

创建管道

创建子进程

做子进程的接收处理

做父进程的发送处理

这里使用管道通信涉及到了一个系统函数：int pipe(int pipefd[2])

用处是我们传入一个一维数组，他会分别以只w写和只r读的方式打开同一个文件，将只读的文件描述符放入pipefd[0]，将只写的文件描述符放入pipefd[1]

其实就是一个简化操作的函数，我们自己以两种方式打开也可以；

简单说一下我们做了什么事情：

（如果是小白）关于头文件的包含和函数我们使用了几个关键函数：fork()、pipe、waitpid()，snprintf()去查相关的man手册即可

这里的代码：

首先通过pipe创建一个管道用pipefd存放，子进程创建一个缓冲区来接收父进程发送的数据。

父进程创建一个缓冲区来存放发送的数据，最后结束等待子进程退出处理。

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

using namespace std;

int main()
{
    // 创建管道
    int pipefd[2] = {0};
    int n = pipe(pipefd); // 创建的pipedfd[0]是读 pipedp[1]是写
    assert(n != -1);
    (void)n;

    // 创建子进程
    pid_t id = fork();
    assert(id >= 0);
    if (id == 0) // 子进程接收处理+关闭写
    {
        close(pipefd[1]);
        // 搞一个缓冲区来接收数据
        while (true)
        {
            char buffer[1024];
            ssize_t s = read(pipefd[0], buffer, sizeof(buffer) - 1);
            buffer[s] = 0;

            cout << getpid() << ":reserve a message from father:" << buffer << endl;
        }
    }
    // 父进程发送处理+关闭读
    close(pipefd[0]);

    char send_Buffer[1024];
    while (true)
    {
        string msg = "儿子我给你发了一个信息";

        snprintf(send_Buffer, sizeof(send_Buffer), "[%d]:%s", getpid(), msg.c_str());
        write(pipefd[1], send_Buffer, strlen(send_Buffer));

        sleep(1);
    }

    //等待子进程退出
    int ret = waitpid(id, nullptr, 0);
    assert(ret > 0);
    (void)ret;

    return 0;
}

四、使用管道不可避免的几个小细节🙋

a.如果写的数据过快，读得慢，缓冲区写满了就不能再写了。

b.如果写的慢，读的块，管道没有数据的时候，读必须等待。

c.写的文件关闭了，读的时候返回0，表示读到了文件结尾。

d.读的文件关闭了，写继续写，操作系统(OS)会终止写进程。

如上四点大家可以自己实践

ab两点可换一种说法即 -- 管道是具有访问控制的，显示器也是一个文件，父子同时往显示器上写入的时候，没有说一个会等待另一个的情况，也就是缺乏访问控制。

五、管道的使用总结😰

管道一般用于父子间通信。

管道具有通过进程间协同，提供的访问控制。

管道提供的是面向流式的通信服务 -- 字节流。

管道是基于文件的，文件的生命周期是随进程的，管道也是。

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

六、命名管道😏

前面五点主要是是介绍匿名管道，这里我们来解释一下命名管道

同样的，进程间通信的实质是让不同的进程看到同一个资源，也就是同一个内存！

而文件加载到内存中时，是有被所有进程访问的潜质的！如下图fifo.ipc文件加载到内存中，AB两个进程一起去访问这个文件。

命名管道：操作系统允许在磁盘中创建管道文件，该文件可以被打开，但是不会将数据刷新到磁盘！管道文件有名字，就一定在系统路径中，具有唯一性！两个进程就可以通过，管道文件的路径，看到同一份资源！！

命令行指令：mkfifo 文件名当前路径创建一个管道文件

demo代码

#include "commit.hpp" 

using namespace std;

int main()
{
    //创建管道
    if (mkfifo(fifopath.c_str(), MODE) < 0)
    {
        perror("mkfifo");
        exit(1);
    }
    //打开文件
    int fd = open(fifopath.c_str(), O_RDONLY);
    if (fd < 0)
    {
        perror("open");
        exit(2);
    }
    //接收信息
    while (true)
    {
        char buffer[SIZE];

        memset(buffer, '/0', sizeof(buffer));
        ssize_t s = read(fd, buffer, sizeof(buffer) - 1);
        buffer[s] = 0;
        if (s == 0)
        {
            break;
        }

        cout << getpid() << "] get a message:" << buffer << endl;
    }

    close(fd);

    unlink(fifopath.c_str());

    return 0;
}

#include "commit.hpp"

int main()
{
    int fd = open(fifopath.c_str(), O_WRONLY);
    assert(fd >= 0);
    //发送信息
    while (true)
    {
        string message;

        cout << "Please Input a Massage:>";
        getline(cin, message);

        write(fd, message.c_str(), message.size());
    }

    close(fd);

    return 0;
}

.PHONY:all
all:clint server

clint:clint.cpp
    g++ -o $@ $^ -std=c++11
server:server.cpp
    g++ -o $@ $^ -std=c++11

.PHONY:clean
clean:
    rm -f clint server

#ifndef _COMMIT_H
#define _COMMIT_H

#include <iostream>
#include <string>
#include <iostream>
#include <sys/types.h>
#include <sys/wait.h>
#include "commit.hpp" 
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <cstring>
#include <cassert>

using namespace std;

#define MODE    0666
#define SIZE    1024

std::string fifopath = "./myfifo.ipc";

#endif