Linux 进程间通信：命名管道（FIFO）实战指南

二、命名管道的创建方式

命名管道有两种创建方式，本质都是在文件系统中生成一个 FIFO 类型的文件。

2.1 命令行创建

适合快速测试，语法简单：

# 创建名为 myfifo 的命名管道
mkfifo myfifo

# 查看管道文件（类型标识为 p）
ls -l myfifo

创建的管道文件最前面的标识是 p 开头。无论写入多少数据，文件大小通常保持不变，验证了它不是普通文件。

2.2 代码创建

通过 mkfifo() 系统调用在代码中创建，需指定管道路径和权限。

#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>

#define FIFO_PATH "./myfifo"

int main() {
    // 创建命名管道，权限 0644
    int ret = mkfifo(FIFO_PATH, 0644);
    if (ret == -1) {
        // 若管道已存在，errno 为 EEXIST，可忽略该错误
        if (errno != EEXIST) {
            perror("mkfifo error");
            return 1;
        }
        printf("命名管道已存在\n");
    } else {
        printf("命名管道创建成功\n");
    }
    return 0;
}

三、命名管道的打开规则

命名管道的打开（open()）行为与普通文件不同，核心是'读端与写端的同步'。仅当管道的读端和写端都被打开后，通信才能正常进行。

注意：实际开发中，建议读端以 O_RDONLY 打开，写端以 O_WRONLY 打开，避免使用 O_RDWR 导致逻辑混乱。

四、实战案例

4.1 案例 1：文件拷贝

通过两个程序配合，实现文件拷贝功能：写端读取本地文件写入管道，读端从管道读取写入目标文件。

写端程序 (file_writer.c)

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

#define FIFO_PATH "./tp"
#define BUF_SIZE 1024

#define ERR_EXIT(m) do { perror(m); exit(EXIT_FAILURE); } while(0)

int main() {
    // 1. 创建命名管道
    int ret = mkfifo(FIFO_PATH, 0644);
    if (ret == -1 && errno != EEXIST) {
        ERR_EXIT("mkfifo error");
    }

    // 2. 打开本地文件（待拷贝的源文件）
    int infd = open("abc", O_RDONLY);
    if (infd == -1) {
        ERR_EXIT("open source file error");
    }

    // 3. 以写方式打开命名管道（阻塞，直到读端打开）
    int outfd = open(FIFO_PATH, O_WRONLY);
    if (outfd == -1) {
        ERR_EXIT("open fifo error");
    }

    // 4. 读取源文件内容，写入管道
    char buf[BUF_SIZE];
    int n;
    while ((n = read(infd, buf, BUF_SIZE)) > 0) {
        if (write(outfd, buf, n) != n) {
            ERR_EXIT("write to fifo error");
        }
    }

    close(infd);
    close(outfd);
    printf("文件内容写入管道完成\n");
    return 0;
}

读端程序 (file_reader.c)

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

#define FIFO_PATH "./tp"
#define BUF_SIZE 1024

#define ERR_EXIT(m) do { perror(m); exit(EXIT_FAILURE); } while(0)

int main() {
    // 1. 以读方式打开命名管道（阻塞，直到写端打开）
    int infd = open(FIFO_PATH, O_RDONLY);
    if (infd == -1) {
        ERR_EXIT("open fifo error");
    }

    // 2. 创建目标文件
    int outfd = open("abc.bak", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (outfd == -1) {
        ERR_EXIT("open target file error");
    }

    // 3. 从管道读取内容，写入目标文件
    char buf[BUF_SIZE];
    int n;
    while ((n = read(infd, buf, BUF_SIZE)) > 0) {
        if (write(outfd, buf, n) != n) {
            ERR_EXIT("write to target file error");
        }
    }

    close(infd);
    close(outfd);
    unlink(FIFO_PATH); // 手动删除管道文件
    printf("文件拷贝完成\n");
    return 0;
}

编译与运行

gcc file_writer.c -o writer
gcc file_reader.c -o reader

# 终端 1：运行读端（阻塞等待写端）
./reader

# 终端 2：运行写端（开始拷贝）
./writer

4.2 案例 2：Server-Client 通信

实现一个简单的 C/S 模型，服务端监听管道，客户端发送消息。

服务端程序 (server.cpp)

注：此示例使用了 C++ 标准库，建议保存为 .cpp 后缀编译

#include <iostream>
#include <cstdio>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>

using namespace std;

const char* fifoname = "./myfifo";

int main() {
    // 1. 创建管道文件
    umask(0);
    int n = mkfifo(fifoname, 0666);
    if (n < 0) {
        perror("mkfifo");
        return 1;
    }

    // 2. 打开管道文件（阻塞等待客户端连接）
    int rfd = open(fifoname, O_RDONLY);
    if (rfd < 0) {
        perror("open");
        return 2;
    }

    char inbuffer[1024];
    // 3. 循环接收客户端消息
    while (true) {
        ssize_t n = read(rfd, inbuffer, sizeof(inbuffer) - 1);
        if (n > 0) {
            inbuffer[n] = 0;
            cout << "client say: " << inbuffer << endl;
        } else if (n == 0) {
            break; // 写端关闭
        } else {
            perror("read");
            break;
        }
    }

    close(rfd);
    unlink(fifoname);
    return 0;
}

客户端程序 (client.cpp)

#include <iostream>
#include <string>
#include <cstdio>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

using namespace std;

const char* fifoname = "./myfifo";

int main() {
    // 1. 以写方式打开管道（阻塞，直到服务端打开读端）
    int wfd = open(fifoname, O_WRONLY);
    if (wfd < 0) {
        perror("open");
        return 1;
    }

    // 2. 循环输入并发送消息给服务端
    string outstring;
    while (true) {
        cout << "Please Enter@ ";
        cin >> outstring;
        write(wfd, outstring.c_str(), outstring.size());
    }

    close(wfd);
    return 0;
}

编译与运行

g++ server.cpp -o server
g++ client.cpp -o client

# 终端 1：启动服务端
./server

# 终端 2：启动客户端
./client

提示：必须先启动服务端再启动客户端，否则客户端会因无法找到读端而阻塞。

五、避坑指南与总结

常见陷阱

1. 必须手动删除管道文件：命名管道创建后会残留于文件系统，若不删除，下次创建会报错（EEXIST），建议在通信结束后用 unlink() 删除。
2. 避免单进程同时读写：虽然可通过 O_RDWR 打开管道实现单进程读写，但会破坏半双工特性，容易导致数据混乱。
3. 处理阻塞场景：读端未打开时写端会阻塞，反之亦然。若需非阻塞操作，可在 open() 时添加 O_NONBLOCK 标志。
4. 数据完整性保证：当写入数据量 ≤ PIPE_BUF（默认 4096 字节）时，内核保证原子性；超过则不保证，需在应用层处理分包。
5. 权限设置合理：创建管道时权限需开放给通信进程，避免因权限不足导致 open() 失败。

总结

命名管道（FIFO）是匿名管道的重要扩展，核心价值在于突破了亲缘进程的限制，通过文件系统路径实现任意进程间的通信，且沿用了 Linux 标准的文件操作接口，上手成本低。

• 它是带文件路径的内核缓冲区，支持跨进程通信。
• 需通过 mkfifo() 或命令创建，open() 时需遵循读写端同步规则。
• 实战中可实现文件拷贝、C/S 通信等场景。
• 与匿名管道相比，核心优势是通信范围无限制，生命周期随内核。

如果需要更高效率的跨进程通信（如高频数据传输），后续可学习共享内存；若需消息结构化传输，可了解消息队列。