Linux 进程间通信之命名管道（FIFO）实战与面向对象封装

下面就需要创建管道了，我们让服务端创建。但是需要注意，创建管道文件是可能失败的，比如管道文件已存在时。

程序结束时还需要删除管道文件，删除文件需要用到 unlink，它不仅是系统调用，也是一个指令，可以用 unlink 指令在命令行删除管道文件。

#include "common.hpp"
int main(){
    int n = mkfifo(fifoname.c_str(), mode);
    if(n == 0){
        std::cout << "mkfifo successful" << std::endl;
    }else{
        std::cout << "mkfifo failed" << std::endl;
    }
    sleep(5);
    int m = unlink(fifoname.c_str());
    (void)m;
    return 0;
}

实现通信

我们准备实现让 client 发送数据然后 server 接受数据。下面先实现 server 端，我们已经创建好管道文件了，下面就需要调用文件的各种系统调用接口打开文件、读取文件、关闭文件，和我们在文件系统介绍的一摸一样，小编就不过多赘述了。

这里小编要补充几点：

1、有关命名管道的操作特点，在打开管道一端，但另一端未打开的时候，open 操作会被阻塞，因为如果不阻塞直接打开就有可能读到 0。

2、读到的数据我们用字符串数组暂存，并且读取时要预留一个位置给\0，所以 read 的第三个参数需要 sizeof(buffer) - 1，读取完毕后自己手动在字符串末尾添加\0。

3、当 read 读到 0 时就意味着 client 退出了，这时我们 server 端也需要退出，所以需要对 read 的返回值进行特殊处理。

//server.cpp
#include "common.hpp"
int main(){
    // 1、创建管道文件
    int n = mkfifo(fifoname.c_str(), mode);
    if(n == 0){
        std::cout << "mkfifo successful" << std::endl;
    }else{
        perror("mkfifo");
        exit(1);
    }
    
    // 2、打开管道文件
    // 命名管道特点，在打开一端，但另一端未打开的时候，open 操作会阻塞
    int fd = open(fifoname.c_str(), O_RDONLY);
    if(fd < 0){
        perror("open");
        exit(2);
    }
    std::cout << "open file success" << std::endl;
    
    // 3、读取管道数据
    char buffer[SIZE] = {0};
    while(true){
        buffer[0] = 0; // 清空字符串
        ssize_t num = read(fd, buffer, sizeof(buffer)-1);
        if(num > 0) // read 失败返回 -1
        {
            buffer[num] = 0; // 保持 C 风格字符串，末尾加 0
            std::cout << "client say# " << buffer << std::endl;
        }else if(num == 0){
            std::cout << "client quit, me too!" << std::endl;
            break;
        }else{
            // read 错误
            break;
        }
        std::cout << "num: " << num << std::endl;
    }
    
    // 4、归还资源
    close(fd);
    int m = unlink(fifoname.c_str());
    (void)m;
    return 0;
}

然后实现 client 端，还是平常打开文件的逻辑，唯一需要注意是处理输入的时候不用 cin，而用 getline，因为 getline 可以读入空格。

//client.cpp
int main(){
    int fd = open(fifoname.c_str(), O_WRONLY);
    if(fd < 0){
        perror("open");
        exit(1);
    }
    std::string message;
    while(true){
        std::cout << "please enter# ";
        getline(std::cin, message); // getline 可以读取空格
        write(fd, message.c_str(), message.size());
    }
    close(fd);
    return 0;
}

现在我们来总结一下：

1、client 和 server 是如何看到同一份资源的？因为命名管道不同于匿名管道，它有文件系统路径标识，所以当 server 和 client 通过路径 + 文件名打开的文件时就能通过路径解析找到唯一的文件 inode，进而保证不同的进程打开的是同一个文件。

2、为什么 fifo 叫命名管道？因为命名管道本身就有名字，并且也有 inode，open 打开文件时如果打开的是命名管道就会对其做特殊处理，我们作为程序员不用操心。

以面向对象封装命名管道

1、构造函数中不写创建管道逻辑，析构函数中不写关闭管道逻辑，而是将创建管道和关闭管道和关闭文件描述符单独写成三个方法，因为客户端和服务端都会使用命名管道，服务端既要读取数据又要打开管道、打开文件、关闭管道、关闭文件描述符，而客户端只打开文件、关闭文件，这样解耦合方便服务端、客户端各自调用自己需要的接口。

2、封装 Close 时添加一个文件描述符默认值判断 defaultfd，defaultfd 默认为 -1，打开管道成功了将 defaultfd 改为管道的 fd，关闭管道后将 defaultfd 重新置为 -1，当 Close 的参数为 -1 时表示程序没有打开管道文件或者已经将管道删除了，这时直接 return，避免对无效 fd 执行 close 导致的系统错误、资源污染。

3、实现面向对象代码时对于参数传递的最佳实践如下：

输入参数：const+&

输出参数：*

输入输出参数：&

源码

//common.hpp
#ifndef __COMMON_HPP__
#define __COMMON_HPP__
#include <stdio.h>
#include <iostream>
#include <string>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>

std::string fifoname = "fifo";
mode_t mode = 0666;
#define SIZE 128 // 缓冲区大小
#endif

//NamedPipe.hpp
#pragma once
#include "common.hpp"

const int defaultfd = -1;

class NamedPipe{
public:
    NamedPipe(const std::string name) : _name(name), _fd(defaultfd) {}
    
    // 创建管道
    bool Create(){
        int n = mkfifo(_name.c_str(), mode);
        if(n == 0){
            std::cout << "mkfifo successful" << std::endl;
        }else{
            perror("mkfifo");
            return false;
        }
        return true;
    }
    
    bool OpenForRead(){
        _fd = open(_name.c_str(), O_RDONLY);
        if(_fd < 0){
            perror("open");
            return false;
        }
        std::cout << "open file success" << std::endl;
        return true;
    }
    
    bool OpenForWrite(){
        _fd = open(_name.c_str(), O_WRONLY);
        if(_fd < 0){
            perror("open");
            return false;
        }
        return true;
    }
    
    // 输出型参数
    bool Read(std::string *out){
        char buffer[SIZE] = {0};
        ssize_t num = read(_fd, buffer, sizeof(buffer)-1);
        if(num > 0) // read 失败返回 -1
        {
            buffer[num] = 0; // 保持 C 风格字符串，末尾加 0
            *out = buffer;
        }else if(num == 0){
            return false;
        }else{
            return false;
        }
        return true;
    }
    
    // 输入型参数
    void Write(const std::string &in){
        write(_fd, in.c_str(), in.size());
    }
    
    // 关闭管道文件描述符（本代码示例中服务端、客户端都需要关闭）
    void Close(){
        if(_fd == defaultfd){
            return; // 直接 return，避免执行无效操作
        }
        int n = close(_fd);
        if(n < 0)
            perror("close");
        _fd = -1;
    }
    
    // 归还管道文件
    void Remove(){
        int m = unlink(_name.c_str());
        (void)m;
    }
    
    ~NamedPipe(){}
private:
    std::string _name; // 管道文件名
    int _fd; // 管道文件描述符
};

//server.cpp
#include "NamedPipe.hpp"
int main(){
    std::string fifoname = "fifo";
    NamedPipe np(fifoname);
    
    // 1、创建管道文件
    np.Create();
    
    // 2、打开管道文件
    np.OpenForRead();
    
    // 3、读取管道数据
    std::string message;
    while(true){
        bool res = np.Read(&message);
        if(res){
            std::cout << "client say# " << message << std::endl;
        }else{
            break;
        }
    }
    
    // 4、归还资源
    np.Close();
    np.Remove();
    return 0;
}

//client.cpp
#include "NamedPipe.hpp"
int main(){
    NamedPipe np(fifoname);
    np.OpenForWrite();
    
    std::string message;
    while(true){
        std::cout << "please enter# ";
        getline(std::cin, message); // getline 可以读取空格
        np.Write(message);
    }
    np.Close();
    return 0;
}

总结

命名管道主要用于在毫无关系的进程之间进行文件级进程通信。其他特点匿名、命名管道相同。