多命名管道创建实现：父与子进程通信的管道命名方案咨询

这个问题其实很好解决，核心思路是利用循环索引为每个子进程生成唯一的管道名称，让父进程和子进程无需额外IPC就能精准对应各自的管道，同时在fork子进程前提前创建管道，避免竞争问题。下面是具体的实现步骤和代码示例：

核心设计思路 #

• 唯一管道命名：基于循环的索引i（从0到numWorker-1）为每个子进程生成一对管道名（因为命名管道是半双工，双向通信需要两个管道：父→子、子→父），比如pipe_p2c_0（父到子）和pipe_c2p_0（子到父）。
• 子进程自动识别管道名：子进程在被fork出来时，会继承当前循环的i值，因此可以直接用这个索引生成和父进程完全一致的管道名，不需要额外传递参数或信息，效率极高。
• 提前创建管道：父进程在fork子进程前先创建好对应管道，确保子进程启动时管道已经存在，避免子进程等待管道创建的问题。

完整代码示例 #

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

#define MAX_PIPE_NAME_LEN 32

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <number_of_workers>\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    int numWorker = atoi(argv[1]);
    if (numWorker <= 0) {
        fprintf(stderr, "Invalid number of workers\n");
        exit(EXIT_FAILURE);
    }

    pid_t childpid;
    char p2c_pipe[MAX_PIPE_NAME_LEN];
    char c2p_pipe[MAX_PIPE_NAME_LEN];

    for (int i = 0; i < numWorker; i++) {
        // 生成当前子进程的一对管道名
        snprintf(p2c_pipe, MAX_PIPE_NAME_LEN, "pipe_p2c_%d", i);
        snprintf(c2p_pipe, MAX_PIPE_NAME_LEN, "pipe_c2p_%d", i);

        // 创建父→子的命名管道，权限设为0666（可根据需求调整）
        if (mkfifo(p2c_pipe, 0666) == -1) {
            if (errno != EEXIST) { // 忽略已存在的管道（如果程序重启）
                perror("Failed to create parent-to-child pipe");
                exit(EXIT_FAILURE);
            }
        }
        // 创建子→父的命名管道
        if (mkfifo(c2p_pipe, 0666) == -1) {
            if (errno != EEXIST) {
                perror("Failed to create child-to-parent pipe");
                exit(EXIT_FAILURE);
            }
        }

        childpid = fork();
        if (childpid == -1) {
            perror("Fork failed");
            exit(EXIT_FAILURE);
        }

        if (childpid == 0) {
            // ---------------------- 子进程逻辑 ----------------------
            printf("Child %d: Using pipes - P2C: %s, C2P: %s\n", i, p2c_pipe, c2p_pipe);

            // 打开父→子管道（只读）
            int p2c_fd = open(p2c_pipe, O_RDONLY);
            if (p2c_fd == -1) {
                perror("Child failed to open P2C pipe");
                exit(EXIT_FAILURE);
            }
            // 打开子→父管道（只写）
            int c2p_fd = open(c2p_pipe, O_WRONLY);
            if (c2p_fd == -1) {
                perror("Child failed to open C2P pipe");
                exit(EXIT_FAILURE);
            }

            // 示例：接收父进程消息并回复
            char buffer[100];
            ssize_t bytes_read = read(p2c_fd, buffer, sizeof(buffer)-1);
            if (bytes_read > 0) {
                buffer[bytes_read] = '\0';
                printf("Child %d received: %s\n", i, buffer);

                // 回复父进程
                char reply[100];
                snprintf(reply, sizeof(reply), "Hello from Child %d", i);
                write(c2p_fd, reply, strlen(reply));
            }

            // 关闭管道并退出
            close(p2c_fd);
            close(c2p_fd);
            exit(EXIT_SUCCESS);
            // ---------------------- 子进程逻辑结束 ----------------------
        }
        // 父进程继续创建下一个子进程
    }

    // ---------------------- 父进程通信逻辑 ----------------------
    for (int i = 0; i < numWorker; i++) {
        snprintf(p2c_pipe, MAX_PIPE_NAME_LEN, "pipe_p2c_%d", i);
        snprintf(c2p_pipe, MAX_PIPE_NAME_LEN, "pipe_c2p_%d", i);

        // 打开父→子管道（只写）
        int p2c_fd = open(p2c_pipe, O_WRONLY);
        if (p2c_fd == -1) {
            perror("Parent failed to open P2C pipe");
            exit(EXIT_FAILURE);
        }
        // 打开子→父管道（只读）
        int c2p_fd = open(c2p_pipe, O_RDONLY);
        if (c2p_fd == -1) {
            perror("Parent failed to open C2P pipe");
            exit(EXIT_FAILURE);
        }

        // 发送消息给子进程
        char msg[100];
        snprintf(msg, sizeof(msg), "Hello to Child %d", i);
        write(p2c_fd, msg, strlen(msg));

        // 接收子进程回复
        char buffer[100];
        ssize_t bytes_read = read(c2p_fd, buffer, sizeof(buffer)-1);
        if (bytes_read > 0) {
            buffer[bytes_read] = '\0';
            printf("Parent received from Child %d: %s\n", i, buffer);
        }

        // 关闭管道
        close(p2c_fd);
        close(c2p_fd);
        // 删除管道（可选，程序结束后清理）
        unlink(p2c_pipe);
        unlink(c2p_pipe);
    }

    // 等待所有子进程结束
    for (int i = 0; i < numWorker; i++) {
        wait(NULL);
    }

    return EXIT_SUCCESS;
}

关键细节说明 #

• 管道权限：mkfifo的权限参数0666会被当前进程的umask影响，如果需要精确控制权限，可以先临时修改umask，比如umask(0);再创建管道。
• 管道清理：程序结束前一定要用unlink删除创建的命名管道，避免残留文件占用系统资源。上面的示例中父进程在和子进程通信完成后就删除了管道，也可以等所有子进程退出后统一清理。
• 错误处理：代码中加入了对EEXIST错误的判断，避免程序重启时因管道已存在而崩溃，你可以根据实际需求调整错误处理逻辑。

内容的提问来源于stack exchange，提问作者Akaitenshi