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

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

2.1 命令行创建（mkfifo 命令）

直接通过 mkfifo 命令创建命名管道，语法简单，适合快速测试：

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

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

执行后你会发现，这里创建的管道文件最前面的标识是 p 开头。就算不停地往里面进行写操作，它的文件大小是一直不变的，验证了它不是一个普通文件。另外当我们直接终止读端的时候，相当于读端关闭，写端还在写，操作系统会发送 SIGPIPE 信号杀死写端进程。

2.2 代码创建（mkfifo 函数）

通过 mkfifo() 系统调用在代码中创建命名管道，需指定管道路径和权限，原型如下：

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

// 参数：pathname-管道路径；mode-权限（如 0644）
int mkfifo(const char *pathname, mode_t mode);

代码示例（创建命名管道）

#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（可能导致通信逻辑混乱）。

四、命名管道实战案例

下面通过两个独立的程序（writer.c 写端、reader.c 读端）演示命名管道的跨进程通信，实现'写端输入数据，读端接收并打印'的功能。

4.1 案例 1：命名管道实现文件拷贝

通过两个程序配合，实现文件拷贝功能：

• file_writer.c：读取本地文件，将内容写入命名管道；
• file_reader.c：从命名管道读取内容，写入目标文件。

4.1.1 写端程序（file_writer.c）

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <errno.h>
#include <string.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. 打开本地文件（待拷贝的源文件 abc）
    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");
        }
    }

    // 5. 关闭文件描述符
    close(infd);
    close(outfd);
    printf("文件内容写入管道完成\n");
    return 0;
}

4.1.2 读端程序（file_reader.c）

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <errno.h>
#include <string.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. 创建目标文件（拷贝后的文件 abc.bak）
    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");
        }
    }

    // 4. 关闭文件描述符，删除命名管道
    close(infd);
    close(outfd);
    unlink(FIFO_PATH); // 手动删除管道文件
    printf("文件拷贝完成\n");
    return 0;
}

4.1.3 编译与运行

# 编译两个程序
gcc file_writer.c -o writer
gcc file_reader.c -o reader

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

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

运行结果：

• 写端读取 abc 文件内容，写入命名管道 tp；
• 读端从 tp 读取内容，写入 abc.bak；
• 拷贝完成后，读端删除管道文件，两个程序退出。

4.2 案例 2：命名管道实现 Server-Client 通信

实现一个简单的 C/S 模型：

• server.c：作为服务端，监听管道，接收客户端消息并打印；
• client.c：作为客户端，向管道发送消息，实现双向交互。

4.2.1 前置准备（Makefile && comm.h）

为了方便管理，我们创建一个简单的 Makefile 和公共头文件。

comm.h

#ifndef COMM_H
#define COMM_H

const char* fifoname = "./myfifo";

#endif

Makefile

CC = g++
CFLAGS = -Wall
TARGET = server client

all: $(TARGET)

server: server.c comm.h
	$(CC) $(CFLAGS) -o server server.c

client: client.c comm.h
	$(CC) $(CFLAGS) -o client client.c

clean:
	rm -f $(TARGET)

4.2.2 服务端程序（server.c）

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

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;
            std::cout << "client say# " << inbuffer << std::endl;
        } else if (n == 0) {
            // 写端关闭了
            break;
        } else {
            perror("read");
            break;
        }
    }

    // 4. 关闭文件描述符
    close(rfd);

    // 5. 删除管道文件
    unlink(fifoname);
    return 0;
}

4.2.3 客户端程序（client.c）

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

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

    // 2. 循环输入并发送消息给服务端
    std::string outstring;
    while (true) {
        std::cout << "Please Enter@ ";
        std::cin >> outstring;
        write(wfd, outstring.c_str(), outstring.size());
        // 不需要写 \0，因为 read 会处理长度
    }

    // 3. 关闭文件描述符
    close(wfd);
    return 0;
}

4.2.4 编译与运行

# 编译程序
make

# 终端 1：启动服务端（阻塞等待客户端）
./server

# 终端 2：启动客户端（输入消息交互）
./client

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

五、命名管道使用避坑指南和总结

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

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

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

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