Linux——进程间通信(管道)

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

我们可以使用多进程协同完成某种业务。

管道

见见猪跑(举个例子)

cat file.txt | grep "mwb" 将file.txt中包含mwb的一行信息给筛选出来了。

这里的' | '就是使用的匿名通信的方式将这两个进程建立了通信，' | '叫做管道。

文件描述符fd与管道的关系(深度理解管道)

进程通信的本质就是让两个进程看到同一份资源，因此在内存中就有这样一块区域(如上图所示)。

我们在冯诺依曼体系结构中已经学过，磁盘的IO速度相对于内存和CPU来说极低，因此我们在进行进程间通信的时候可以不用访问磁盘，在内存中就可以实现。

进程具有独立性，当我们使用上述区域就可以实现父子进程之间通信。

什么是管道？

管道是Unix中最古老的进程间通信的形式。
我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”

who程序运行成进程后，将数据输出到管道中，然后管道又将数据输入到wc进程中。

匿名管道

匿名管道可以让父子间进行进行通信。

pipe函数概述

函数原型

int pipe(int fd[2]);

pipe函数里面的这个参数是一个输出型参数，也就是当我们使用pipe函数的时候，可以得到fd[0]和fd[1]。这两个分别被称为读端和写端，匿名管道如同在生活中的天然气管道。只能从天然气公司到你家，是单向的。

参数

fd[2]是一个文件描述符数组。

fd[0]为读端(为了便于记忆我们可以把0当做一个嘴巴)

fd[1]为写端(为了便于记忆我们可以把1当做一支笔)

返回值

成功返回0，失败返回错误代码。

单个进程中文件描述符与管道的关系

父子进程通信时与文件描述符的关系图(理解pipe函数的关键)

由于每个进城都有对应的写端和读端，当我们希望让父子进程进行通信的时候(比如让父进程写，子进程读)如上图。我们需要把父进程的读端和子进程的写端给关闭，以防被别人不小心的使用造成不必要的麻烦。

因此我们只需要让父子进程分别以读写方式打开同一个文件(本质就是看到同一块资源)。

pipe函数的使用

注意：代码中是子进程进行写入，父进程读取！

代码中有详细的解析！

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

using namespace std;

// 父进程写，子进程读
// 父进程关闭读端(fd[0])，子进程关闭写端(fd[1])

int main()
{
    // 定义一个fd的数组
    int fd[2] = {0};
    // 接受一下pipe的返回值进行断言判断
    int a = pipe(fd);
    assert(a == 0);

    // fork创建子进程
    pid_t id = fork();
    // 以防创建失败，创建失败后面的代码就没有意义了
    assert(id >= 0);

    // 子进程
    if (id == 0)
    {
        // 子进程关闭读端
        close(fd[0]);

        // 定义一个字符串用作管道中的内容
        const char *msg = "### 你好父进程 ，我是子进程！###";
        int count = 6;
        while (count--)
        {
            cout << "count: " << count << endl;
            // 将文件内容输入管道中
            write(fd[1], msg, strlen(msg));
            sleep(1);
        }

        // 子进程写入完毕关闭写端
        close(fd[1]);
        // 成功退出子进程
        exit(0);
    }

    // 父进程

    // 父进程关闭写端
    close(fd[1]);

    // 定义一个数组来接受读到的字符串
    char buffer[1024];

    // 死循环的读取(若读完管道的内容或者读取失败会在while函数体中进行break)
    while (1)
    {

        // 使用read读出管道的内容读到buffer中
        ssize_t s = read(fd[0], buffer, sizeof(buffer));
        if (s > 0)
        {
            // buffer[s]='\n';
            cout << "父进程收到了子进程的信息：" << buffer << endl;
        }

        // s==0已经读到了管道内容的结尾
        else if (s == 0)
        {
            cout << "父进程已经读取完了！" << endl;
            break;
        }

        else
        {
            cout << "读取错误！" << endl;
            cout << "s: " << s << endl;
            break;
        }

        // sleep(1);
    }

    // 父进程读取完毕，关闭写端
    close(fd[0]);

    // 定义一个status用来接受一下子进程的退出码
    int status;
    waitpid(id, &status, 0);
    cout << "退出码：" << ((status >> 8) & 0xFF) << endl;

    return 0;
}

现象：

用fork来共享管道

管道读写规则

1、当管道里面没有数据的时候，会阻塞当前的读端的进程，直到管道里面有数据才会被唤醒。

2、当管道里面数据被写满时会阻塞当前的写入进程，直到管道里面的数据被读取后(管道有空间后)会唤醒写入进行。

3、如果写入进程关闭了写端，读进程会把管道里面的数据读完然后成功退出。

4、如果读进程关闭了读端，操作系统就会向写进程发送13号信号SIGPIPE来杀死写进程。

管道的大小

自测

我们可以使用父进程向管道里面不断的写入数据，以每次写入一字节进行计数。然后让子进程sleep起来，当管道写满后就会阻塞，此时计数的值就是管道的大小。

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

using namespace std;

// 父进程写，子进程读
// 父进程关闭读端(fd[0])，子进程关闭写端(fd[1])

int main()
{
    int fd[2] = {0};
    int a = pipe(fd);
    assert(a == 0);

    // fork创建子进程
    pid_t id = fork();

    // 子进程
    if (id == 0)
    {
        // 子进程关闭读端
        close(fd[0]);
        // close(fd[0]);

        const char *msg = "a";
        int count = 0;
        while (1)
        {
            cout << "count: " << count << endl;
            write(fd[1], msg, strlen(msg));
            count++;
        }
        
        close(fd[1]);
        exit(0);
    }

    // 父进程

    close(fd[1]);
    // close(fd[0]);

    char buffer[1024];

    while (1)
    {
        sleep(10000);
        ssize_t s = read(fd[0], buffer, sizeof buffer);
        if (s > 0)
        {
            // buffer[s]='\n';
            cout << "父进程收到了子进程的信息：" << buffer << endl;
        }
        else if (s == 0)
        {
            cout << "父进程已经读取完了！" << endl;
            break;
        }
        else
        {
            cout << "读取错误！" << endl;
            cout << "s: " << s << endl;
            break;
        }
        sleep(1);
    }

    // 父进程读取完毕

    close(fd[0]);

    int status;
    waitpid(id, &status, 0);
    cout << "退出码：" << ((status >> 8) & 0xFF) << endl;

    return 0;
}

由运行结果可以发现，count的值阻塞在65536，因此当前管道的大小为65536byte。

使用man 7 pipe查看

man手册上面之处2.6.11后的版本是65536，那么我们查看一下我们的版本。

是2.6.11后的版本，因此是65536。

使用ulimit -a查看

通过ulimit -a查看到 pipe size 一次原子写入为：512Bytes*8=4096Bytes

查看缓冲条目个数：cat /usr/src/kernels/内核版本/include/linux/pipe_fs_i.h文件

所以我的pc下得pipe缓冲大小为：16*4096=65536Bytes

也就验证了man 7 pipe下的pipe capacity。

管道的特征

1、管道的生命周期随进程。

2、管道可以用来进行具有血缘关系的进程之间进行通信，常用于父子通信。

3、管道是面向字节流的(网络)。

4、半双工——单向通信(特殊概念)。

5、同步于互斥机制 —— 对共享资源进行保护的方案。

命名管道

概念

管道应用的一个限制就是只能在具有共同祖先(具有亲缘关系)的进程间通信。
如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作，它经常被称为命名管道。
命名管道是一种特殊类型的文件。

mkfifo函数

先举例说明

使用mkfifo创建一个命名管道

当我们向管道里面写入数据的时候，但是反复去查看named_pipe的大小的时候，发现大小一直为0，并没改变，这也印证了我们之前说的管道并不在磁盘这一观点。

下列gif图中我们左边向管道中进行不断的重定向一些数据，然后右边使用cat可以读取到我们管道中的数据。

并且需要我们注意的是，当我们Ctrl+C中断当前正在运行的程序或命令时，左边直接就退出了，也印证了之前我们说的当把读进程的读端给关闭的时候，写进程就会被杀死！

mkfifo函数

首先通过man手册去查看mkfifo函数。

第二个参数是权限。

用命名管道实现serve与client通信

comm.hpp

#pragma once

#include <iostream>
#include <string>
#include <cerrno>
#include <cstring>
#include <cassert>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define NAMED_PIPE "/tmp/mypipe"

//创建管道文件函数
bool createFifo(const std::string& path)
{
    umask(0);

    // 创建管道文件
    int n=mkfifo(path.c_str(),0600);

    if(n==0)
        return true;

    else
    {
        std::cout<<"error:"<<errno<<"error string"<<strerror(errno)<<std::endl;
        return false;
    }
}

//销毁管道
void destroyFifo(const std::string& path)
{
    int n=unlink(NAMED_PIPE);
    assert(n==0);
    (void)n;
}

client.cc

#include "comm.hpp"

int main()
{

    // 客户端以只写的方式打开文件
    int wfd = open(NAMED_PIPE, O_WRONLY);
    if (wfd == -1) // 打开失败
    {
        exit(1);
    }
    char buffer[1024];

    while (true)
    {

        std::cout << "you can say:";

        //这里使用fgets来获得我们从键盘中输入的字符串
        fgets(buffer, sizeof(buffer), stdin); // fgets剩一个空间会被系统填充'\0',不用-1

        ssize_t s = write(wfd, buffer, strlen(buffer));

        assert(s == strlen(buffer));
        (void)s;
    }
    
    close(wfd);
    return 0;
}

server.cc

#include "comm.hpp"
int main()
{
    // 创建一个文件
    bool c=createFifo(NAMED_PIPE);

    // assert(c);
    // // 以免c没被用到而报错
    // (void)c;

    std::cout << "server begin" << std::endl;

    //会等用户端打开管道文件，服务端才进行open服务端以只读的方式打开
    int rfd =open(NAMED_PIPE,O_RDONLY);


    //打开失败
    if(rfd==-1)
    {
        //异常退出
        exit(1);
    }
        
    //读取
    char buffer[1024];

    while(true)
    {

        ssize_t s=read(rfd,buffer,sizeof(buffer)-1);

        if(s>0)
        {
            buffer[s]=0;//将最后一个字符设置为'\0'
            std::cout<<"client->server:"<<buffer;
        }
        // 说明服务端一直没有接收到数据
        else if(s==0)
        {
            std::cout << "client quit, me too!" << std::endl;
            break;
        }

        else//读取出错
        {
            std::cout<<"err string"<<strerror(errno)<<std::endl;
            break;
        }
    }

    close(rfd);

    destroyFifo(NAMED_PIPE);
    return 0;
}

gif动图演示：

comm.hpp

对于如何让客户端和服务端使用同一个命名管道文件，这里我们可以让客户端和服务端包含同一个头文件，该头文件当中提供这个共用的命名管道文件的文件名，这样客户端和服务端就可以通过这个文件名，打开同一个命名管道文件，进而进行通信了。

步骤：

1、首先让服务端运行起来，让服务端创建一个文件。然后再以读的方式去打开这个文件。

2、对于客户端来说，服务端已经把文件创建完毕，客户端只需要以写的方式打开文件，将通信信息写入文件就行。

3、当我们在最后ctrl c关闭客户端的时候，此时服务端检查到管道文件中没数据可读的时候就也关闭了。