Linux C语言命名管道的跨进程通信

一、引言

在Linux环境下，进程间通信（IPC，Inter - Process Communication）是一个重要的话题。不同进程之间需要交换数据、传递信号等，以协同完成复杂的任务。命名管道（Named Pipe），也称为FIFO（First - In - First - Out），是一种常用的进程间通信机制。与匿名管道（Anonymous Pipe）不同，命名管道在文件系统中有对应的文件名，这使得不相关的进程也能通过它进行通信。在C语言中，我们可以借助系统调用方便地使用命名管道进行跨进程通信。

二、命名管道基础

2.1 什么是命名管道

命名管道是一种特殊类型的文件，它遵循先进先出的原则。数据从管道的一端写入，从另一端读出。与普通文件不同，命名管道并不在磁盘上存储数据，而是在内存中维护一个缓冲区。当一个进程向命名管道写入数据时，数据会被拷贝到管道的缓冲区中，直到有另一个进程从管道中读取数据。

2.2 命名管道的特点

1. 半双工通信：默认情况下，命名管道是半双工的，即数据只能在一个方向上流动。不过，通过创建两个命名管道，可以实现全双工通信。
2. 同步机制：命名管道本身提供了一定的同步机制。当管道缓冲区满时，写入操作会被阻塞，直到有数据被读取；当管道缓冲区为空时，读取操作会被阻塞，直到有数据被写入。
3. 文件系统实体：命名管道在文件系统中有对应的节点，这使得不同进程可以通过文件路径来访问它，即使这些进程之间没有亲缘关系。

2.3 命名管道与匿名管道的区别

1. 匿名管道：匿名管道是一种临时的通信机制，它没有名字，只能用于具有亲缘关系（如父子进程）的进程之间。匿名管道在创建时，内核为其分配一个管道文件描述符对（一个用于读，一个用于写），进程结束后，匿名管道随之消失。
2. 命名管道：命名管道有一个文件系统中的名字，任何具有适当权限的进程都可以通过这个名字来访问它。命名管道在创建后会一直存在于文件系统中，直到被显式删除。

三、Linux系统调用与命名管道

3.1 创建命名管道 - mkfifo函数

在C语言中，我们使用mkfifo函数来创建一个命名管道。其函数原型如下：

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

int mkfifo(const char *pathname, mode_t mode);

• pathname：指定要创建的命名管道的路径名。
• mode：指定命名管道的权限，与open函数中的mode参数类似，通常使用八进制表示，如0666表示可读可写权限。

返回值：成功时返回0，失败时返回 - 1，并设置errno以指示错误原因。

例如，创建一个名为myfifo的命名管道：

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

int main() {
    int ret = mkfifo("myfifo", 0666);
    if (ret == -1) {
        perror("mkfifo error");
        exit(EXIT_FAILURE);
    }
    printf("Named pipe created successfully.\n");
    return 0;
}

3.2 打开命名管道 - open函数

创建命名管道后，我们需要使用open函数来打开它，以便进行读写操作。open函数的原型如下：

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

int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);

对于命名管道，flags参数通常有以下几种取值：

• O_RDONLY：以只读方式打开。
• O_WRONLY：以只写方式打开。
• O_RDWR：以读写方式打开（不常用，因为命名管道通常是半双工的）。

例如，以只读方式打开myfifo命名管道：

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

int main() {
    int fd = open("myfifo", O_RDONLY);
    if (fd == -1) {
        perror("open error");
        exit(EXIT_FAILURE);
    }
    printf("Named pipe opened for reading.\n");
    close(fd);
    return 0;
}

3.3 读写命名管道 - read和write函数

打开命名管道后，我们可以使用read和write函数进行数据的读写。 read函数原型：

#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);

• fd：命名管道的文件描述符。
• buf：用于存储读取数据的缓冲区。
• count：期望读取的字节数。

返回值：成功时返回实际读取的字节数，0表示到达文件末尾（对于命名管道，通常不会返回0，除非管道另一端关闭），失败时返回 - 1，并设置errno。

write函数原型：

#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);

• fd：命名管道的文件描述符。
• buf：包含要写入数据的缓冲区。
• count：要写入的字节数。

返回值：成功时返回实际写入的字节数，失败时返回 - 1，并设置errno。

3.4 关闭命名管道 - close函数

当完成对命名管道的操作后，需要使用close函数关闭文件描述符，以释放资源。

#include <unistd.h>

int close(int fd);

fd为命名管道的文件描述符。成功时返回0，失败时返回 - 1，并设置errno。

四、命名管道跨进程通信示例

4.1 简单的单向通信示例

假设我们有一个写进程和一个读进程，写进程向命名管道写入一条消息，读进程从命名管道读取这条消息。

写进程代码（writer.c）

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

#define FIFO_NAME "myfifo"
#define BUFFER_SIZE 100

int main() {
    int fd;
    char buffer[BUFFER_SIZE] = "Hello, named pipe!";

    // 以只写方式打开命名管道
    fd = open(FIFO_NAME, O_WRONLY);
    if (fd == -1) {
        perror("open error");
        exit(EXIT_FAILURE);
    }

    // 向命名管道写入数据
    ssize_t bytes_written = write(fd, buffer, strlen(buffer));
    if (bytes_written == -1) {
        perror("write error");
        close(fd);
        exit(EXIT_FAILURE);
    }

    printf("Data written to named pipe: %s\n", buffer);
    close(fd);
    return 0;
}

读进程代码（reader.c）

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

#define FIFO_NAME "myfifo"
#define BUFFER_SIZE 100

int main() {
    int fd;
    char buffer[BUFFER_SIZE];

    // 以只读方式打开命名管道
    fd = open(FIFO_NAME, O_RDONLY);
    if (fd == -1) {
        perror("open error");
        exit(EXIT_FAILURE);
    }

    // 从命名管道读取数据
    ssize_t bytes_read = read(fd, buffer, BUFFER_SIZE - 1);
    if (bytes_read == -1) {
        perror("read error");
        close(fd);
        exit(EXIT_FAILURE);
    }
    buffer[bytes_read] = '\0';

    printf("Data read from named pipe: %s\n", buffer);
    close(fd);
    return 0;
}

在上述示例中，我们首先创建了一个名为myfifo的命名管道（可以在运行读写进程前手动创建，也可以在代码中添加创建命名管道的逻辑）。写进程打开命名管道并写入一条消息，读进程打开命名管道并读取这条消息。

4.2 双向通信示例

为了实现双向通信，我们可以创建两个命名管道，一个用于从进程A到进程B的通信，另一个用于从进程B到进程A的通信。

进程A代码（processA.c）

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

#define FIFO1 "fifo1"
#define FIFO2 "fifo2"
#define BUFFER_SIZE 100

int main() {
    int fd1, fd2;
    char send_buffer[BUFFER_SIZE] = "Message from A to B";
    char recv_buffer[BUFFER_SIZE];

    // 创建两个命名管道
    if (mkfifo(FIFO1, 0666) == -1 && errno != EEXIST) {
        perror("mkfifo FIFO1 error");
        exit(EXIT_FAILURE);
    }
    if (mkfifo(FIFO2, 0666) == -1 && errno != EEXIST) {
        perror("mkfifo FIFO2 error");
        unlink(FIFO1);
        exit(EXIT_FAILURE);
    }

    // 打开FIFO1用于写，FIFO2用于读
    fd1 = open(FIFO1, O_WRONLY);
    if (fd1 == -1) {
        perror("open FIFO1 error");
        unlink(FIFO1);
        unlink(FIFO2);
        exit(EXIT_FAILURE);
    }
    fd2 = open(FIFO2, O_RDONLY);
    if (fd2 == -1) {
        perror("open FIFO2 error");
        close(fd1);
        unlink(FIFO1);
        unlink(FIFO2);
        exit(EXIT_FAILURE);
    }

    // 向FIFO1写入数据
    ssize_t bytes_written = write(fd1, send_buffer, strlen(send_buffer));
    if (bytes_written == -1) {
        perror("write error");
        close(fd1);
        close(fd2);
        unlink(FIFO1);
        unlink(FIFO2);
        exit(EXIT_FAILURE);
    }
    printf("Data sent from A to B: %s\n", send_buffer);

    // 从FIFO2读取数据
    ssize_t bytes_read = read(fd2, recv_buffer, BUFFER_SIZE - 1);
    if (bytes_read == -1) {
        perror("read error");
        close(fd1);
        close(fd2);
        unlink(FIFO1);
        unlink(FIFO2);
        exit(EXIT_FAILURE);
    }
    recv_buffer[bytes_read] = '\0';
    printf("Data received from B to A: %s\n", recv_buffer);

    close(fd1);
    close(fd2);
    unlink(FIFO1);
    unlink(FIFO2);
    return 0;
}

进程B代码（processB.c）

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

#define FIFO1 "fifo1"
#define FIFO2 "fifo2"
#define BUFFER_SIZE 100

int main() {
    int fd1, fd2;
    char send_buffer[BUFFER_SIZE] = "Message from B to A";
    char recv_buffer[BUFFER_SIZE];

    // 创建两个命名管道（如果未创建）
    if (mkfifo(FIFO1, 0666) == -1 && errno != EEXIST) {
        perror("mkfifo FIFO1 error");
        exit(EXIT_FAILURE);
    }
    if (mkfifo(FIFO2, 0666) == -1 && errno != EEXIST) {
        perror("mkfifo FIFO2 error");
        unlink(FIFO1);
        exit(EXIT_FAILURE);
    }

    // 打开FIFO1用于读，FIFO2用于写
    fd1 = open(FIFO1, O_RDONLY);
    if (fd1 == -1) {
        perror("open FIFO1 error");
        unlink(FIFO1);
        unlink(FIFO2);
        exit(EXIT_FAILURE);
    }
    fd2 = open(FIFO2, O_WRONLY);
    if (fd2 == -1) {
        perror("open FIFO2 error");
        close(fd1);
        unlink(FIFO1);
        unlink(FIFO2);
        exit(EXIT_FAILURE);
    }

    // 从FIFO1读取数据
    ssize_t bytes_read = read(fd1, recv_buffer, BUFFER_SIZE - 1);
    if (bytes_read == -1) {
        perror("read error");
        close(fd1);
        close(fd2);
        unlink(FIFO1);
        unlink(FIFO2);
        exit(EXIT_FAILURE);
    }
    recv_buffer[bytes_read] = '\0';
    printf("Data received from A to B: %s\n", recv_buffer);

    // 向FIFO2写入数据
    ssize_t bytes_written = write(fd2, send_buffer, strlen(send_buffer));
    if (bytes_written == -1) {
        perror("write error");
        close(fd1);
        close(fd2);
        unlink(FIFO1);
        unlink(FIFO2);
        exit(EXIT_FAILURE);
    }
    printf("Data sent from B to A: %s\n", send_buffer);

    close(fd1);
    close(fd2);
    unlink(FIFO1);
    unlink(FIFO2);
    return 0;
}

在这个双向通信示例中，进程A和进程B分别创建并使用两个命名管道fifo1和fifo2。进程A通过fifo1向进程B发送消息，同时通过fifo2从进程B接收消息；进程B则反之。

五、命名管道使用中的注意事项

5.1 阻塞与非阻塞模式

1. 阻塞模式：默认情况下，open、read和write操作在命名管道上是阻塞的。例如，当以O_WRONLY方式打开命名管道时，如果没有进程以O_RDONLY方式打开该管道，open操作会阻塞，直到有进程打开管道用于读取。同样，read操作会在管道缓冲区为空时阻塞，write操作会在管道缓冲区满时阻塞。
2. 非阻塞模式：可以通过在open时设置O_NONBLOCK标志来使命名管道的操作变为非阻塞。例如：

int fd = open("myfifo", O_WRONLY | O_NONBLOCK);

在非阻塞模式下，open操作会立即返回，如果管道没有准备好（如以O_WRONLY打开但没有读端打开），open会返回 - 1并设置errno为ENXIO。read操作如果管道缓冲区为空会立即返回 - 1并设置errno为EAGAIN或EWOULDBLOCK；write操作如果管道缓冲区满也会立即返回 - 1并设置errno为EAGAIN或EWOULDBLOCK。

5.2 权限问题

1. 创建权限：在使用mkfifo创建命名管道时，需要注意mode参数设置的权限。例如，如果设置为0600，只有管道的所有者可以读写，其他用户无法访问。
2. 访问权限：进程在打开命名管道时，需要有相应的权限。如果权限不足，open操作会失败并返回 - 1，同时设置errno为EACCES。

5.3 管道缓冲区大小

命名管道的缓冲区大小是有限的，不同系统可能有所不同。在Linux系统中，可以通过ulimit -p命令查看默认的管道缓冲区大小。当写入的数据量超过缓冲区大小时，write操作会阻塞，直到有数据被读取，从而腾出空间。

5.4 管道的删除与清理

1. 删除命名管道：当不再需要命名管道时，应该使用unlink函数删除它。例如：

unlink("myfifo");

2. 进程结束时的清理：在进程结束时，应该确保关闭所有打开的命名管道文件描述符，以避免资源泄漏。同时，如果进程创建了命名管道，在进程结束前最好删除它，除非有其他进程还需要使用它。

六、命名管道与其他IPC机制的比较

6.1 与消息队列的比较

1. 数据结构：
   • 命名管道：按先进先出顺序传输字节流数据，数据没有明确的边界。
   • 消息队列：以消息为单位传输数据，每个消息有一个类型字段，可以根据类型进行选择性接收。
2. 同步机制：
   • 命名管道：通过缓冲区的满空状态实现简单的同步，读写操作会根据缓冲区状态阻塞或非阻塞。
   • 消息队列：提供了更复杂的同步机制，如消息的发送和接收可以通过信号量等进行同步控制。
3. 适用场景：
   • 命名管道：适用于需要连续传输数据且对数据顺序敏感的场景，如简单的数据流传输。
   • 消息队列：适用于需要按类型处理不同消息的场景，如分布式系统中的异步消息处理。

6.2 与共享内存的比较

1. 数据存储：
   • 命名管道：数据在内存中的管道缓冲区中，不直接存储在共享区域。
   • 共享内存：允许不同进程共享同一块内存区域，数据直接存储在共享内存中。
2. 同步机制：
   • 命名管道：自身提供一定的同步机制，基于缓冲区状态。
   • 共享内存：本身不提供同步机制，需要结合信号量、互斥锁等其他同步工具来保证数据的一致性和避免竞争条件。
3. 性能：
   • 命名管道：由于数据需要在进程间拷贝，性能相对较低，尤其是在大数据量传输时。
   • 共享内存：性能较高，因为进程可以直接访问共享内存区域，减少了数据拷贝的开销。但同步开销可能会影响整体性能。

6.3 与套接字的比较

1. 通信范围：
   • 命名管道：主要用于同一台主机上的进程间通信。
   • 套接字：不仅可以用于同一主机上的进程间通信（通过UNIX域套接字），还可以用于不同主机之间的网络通信（通过TCP/IP套接字）。
2. 灵活性：
   • 命名管道：功能相对单一，专注于简单的进程间数据传输。
   • 套接字：具有更高的灵活性，可以实现不同的网络协议（如TCP、UDP），支持多种通信模式。
3. 复杂性：
   • 命名管道：使用相对简单，系统调用较为直接。
   • 套接字：在网络通信场景下，需要处理网络地址、端口、连接管理等复杂问题，使用相对复杂。

七、总结

命名管道是Linux系统中一种重要的进程间通信机制，通过C语言的系统调用，我们可以方便地创建、打开、读写和关闭命名管道。它适用于许多需要进程间数据传输的场景，特别是在同一主机上，对数据顺序敏感且不需要复杂数据结构的情况。在使用命名管道时，需要注意阻塞与非阻塞模式、权限问题、缓冲区大小以及管道的清理等。与其他IPC机制相比，命名管道有其独特的优势和适用场景。深入理解命名管道的原理和使用方法，能够帮助我们更好地设计和实现复杂的Linux应用程序。