进程通信——管道

什么是进程通信？

进程通信是实现进程间传递数据信息的机制。要实现数据信息传递就要进程间共享资源——内存空间。那么是哪块内存空间呢？进程间是相互独立的，一个进程不可能访问其他进程的内存空间，那么这块空间只能由操作系统提供。进程通信的方式有多种，管道就是一种。

管道是一种最简单的通信机制，管道分为匿名管道和命名管道。匿名管道通常用于父子进程之间。命名管道可实现任意两个进程通信。

匿名管道

原理

父进程打开管道文件流（读写两个流），分配描述符到文件描述符表。两个新的文件描述符分别指向管道的读端和写端。父进程创建子进程时，子进程的文件描述符表和父进程指向相同。父子进程指向的文件流都是共享的。

父子进程通信时，如果子进程写，父进程读，子进程关闭pipe_r，父进程关闭pipe_w；如果子进程读，父进程写，子进程关闭pipe_w，父进程关闭pipe_r。

使用样例

pipefd是一个输出型参数，pipefd[0] 表示的是读端的文件描述符，pipefd[1]表示的是写端文件描述符

创建管道->创建子进程->子进程关闭读端，写；父进程关闭写端，读->父进程等待子进程

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

using namespace std;
void Write(int fd)
{
    char buffer[1024] = {0};
    pid_t id = getpid();
    int n = 0;
    string s = "I am child";
    while(1)
    {
        snprintf(buffer,sizeof(buffer),"%s-%d-%d",s.c_str(),id,n);
        n++;
        write(fd,buffer,sizeof(buffer));
        sleep(1);
        if(n == 5) break;
    }
}

void Read(int fd)
{
    char buffer[1024] = {0};
    while(1)
    {
        ssize_t s = read(fd,buffer,sizeof(buffer));
        if(s > 0)
        {
            cout << buffer << endl;
        }
        else if(s == 0)
        {
            cout << "read ending" << endl;
            break;
        }
        else{
            cout << "read fail" << endl;
        }
    }
}


int main()
{
    int pipefd[2] = {0};
    pipe(pipefd);
    pid_t id = fork();
    if(id < 0) return -1;
    if(id == 0)
    {
        //child
        close(pipefd[0]);//关闭读端
        Write(pipefd[1]);

        //close(pipefd[1]);
        exit(0);
    }
    //father
    close(pipefd[1]);//关闭写端
    Read(pipefd[0]);
    
    pid_t ret = waitpid(id,nullptr,0);
    if(ret==id) cout << "wait success" << endl;
    else cout << "wait fail" << endl;
    //close(pipefd[0]);
    return 0;
}

命名管道

命名管道原理和匿名管道一样，区别就是命名管道会创建一个管道文件，两个进程分别对文件读写就可以了

使用样例

创建管道文件

销毁管道文件

//communicate.hpp 创建销毁管道进行封装
#include <iostream>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>

class Init
{
public:
    Init()
    {
        int n = mkfifo("./myfifo", 0777);
        if (n == -1)
        {
            perror("fifo:");
            exit(-1);
        }
    }

    ~Init()
    {
        int n = unlink("./myfifo");
        if(n == -1)
        {
            perror("unlink:");
            exit(-1);
        }
    }
};

//sever.cpp 服务器负责维护管道，读客户端数据
#include "communicate.hpp"
using namespace std;
int main()
{
    // 创建管道
    Init init;
    // 打开管道
    int fd = open("./myfifo", O_RDONLY);
    if (fd == -1)
    {
        cout << strerror(errno) << endl;
        return -1;
    }

    // 开始通信
    while (1)
    {
        char buffer[1024] = {0};
        ssize_t ret = read(fd, buffer, sizeof(buffer));
        if (ret > 0)
        {
           cout << "sever get inf:" << buffer << endl;
        }
        else if (ret == 0)
        {
            cout << "client quit, sever quit too" << endl;
            break;
        }
        else
            break;
    }

    // 结束通信
    close(fd);
}

//client.cpp 客户端负责向服务器写数据
#include "communicate.hpp"

using namespace std;

int main()
{
    //打开管道
    int fd = open("./myfifo", O_WRONLY);
    if(fd < 0)
    {
        cout << strerror(errno) << endl;
        return -1;
    }

    //进行通信
   while(1)
   {
        string ord;
        cout << "Input:";
        getline(cin, ord);
        write(fd, ord.c_str(), ord.size());
   }

   close(fd);
   return 0;
}