【Linux操作系统】详解Linux系统编程中的管道进程通信

旧城等待， 2024-03-23 23:15 40阅读 0赞

> 在Linux系统编程中，管道是一种常用的进程间通信方式。它可以实现父子进程之间或者兄弟进程之间的数据传输。本文将介绍如何使用管道在Linux系统中进行进程通信，并给出相应的代码示例。

![在这里插入图片描述][969be700a4ec4b7d8802a40ccfda67c2.png]

#### 文章目录 ####

*   *  1. 管道的概念
     *  2. 管道的创建和使用
     *   *  2.1 原型
         *  2.2 示例
     *  3. 父子进程通信
     *  4. 兄弟进程间通信
     *  5. fifo函数
     *  6. fifo实现血缘关系进程间通信
     *  7. 管道的特性和限制
     *  8. 总结

### 1. 管道的概念 ###

管道是一种特殊的文件，它提供了一个缓冲区用于进程间的数据传输。管道可以分为两种类型：匿名管道和命名管道。

*  **匿名管道**：匿名管道是一种临时的管道，只能在有亲缘关系的进程之间使用，通常用于父子进程之间的通信。匿名管道只能在创建它的进程及其子进程之间使用，其他进程无法访问。
 *  **命名管道**：命名管道是一种有名字的管道，可以在不同的进程之间进行通信。命名管道通过在文件系统中创建一个文件来实现，进程可以通过该文件来读写数据。

***在本文中，我们将重点介绍匿名管道的使用。***

### 2. 管道的创建和使用 ###

#### 2.1 原型 ####

在Linux系统中，可以使用`pipe`函数来创建一个管道。`pipe`函数的原型如下：

int pipe(int pipefd[2]);

`pipefd`是一个整型数组，用于存储管道的读写文件描述符。`pipefd[0]`用于读取管道中的数据，`pipefd[1]`用于写入管道中的数据。

#### 2.2 示例 ####

下面是一个简单的示例代码，演示了如何使用管道进行父子进程之间的通信：

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <string.h>
    
    int main() {
        
        int pipefd[2];
        pid_t pid;
        char buf[1024];
    
        // 创建管道
        if (pipe(pipefd) == -1) {
        
            perror("pipe");
            exit(EXIT_FAILURE);
        }
    
        // 创建子进程
        pid = fork();
        if (pid == -1) {
        
            perror("fork");
            exit(EXIT_FAILURE);
        }
    
        if (pid == 0) {
        
            // 子进程写入数据到管道
            close(pipefd[0]); // 关闭读取端
            char* msg = "Hello, parent!";
            write(pipefd[1], msg, strlen(msg) + 1);
            close(pipefd[1]); // 关闭写入端
            exit(EXIT_SUCCESS);
        } else {
        
            // 父进程读取管道中的数据
            close(pipefd[1]); // 关闭写入端
            read(pipefd[0], buf, sizeof(buf));
            printf("Received message from child: %s\n", buf);
            close(pipefd[0]); // 关闭读取端
            exit(EXIT_SUCCESS);
        }
    }

在上述代码中，首先使用`pipe`函数创建了一个管道。然后使用`fork`函数创建了一个子进程。子进程使用`write`函数将数据写入管道，父进程使用`read`函数从管道中读取数据。

### 3. 父子进程通信 ###

父进程创建管道，并创建子进程后，父进程通过管道向子进程发送数据，子进程通过管道接收父进程发送的数据。

***下面是一个示例代码，演示了父子进程之间使用管道进行通信的过程：***

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <string.h>
    
    int main() {
        
        int pipefd[2];
        pid_t pid;
        char buf[1024];
    
        // 创建管道
        if (pipe(pipefd) == -1) {
        
            perror("pipe");
            exit(EXIT_FAILURE);
        }
    
        // 创建子进程
        pid = fork();
        if (pid == -1) {
        
            perror("fork");
            exit(EXIT_FAILURE);
        }
    
        if (pid == 0) {
        
            // 子进程读取管道中的数据
            close(pipefd[1]); // 关闭写入端
            read(pipefd[0], buf, sizeof(buf));
            printf("Received message from parent: %s\n", buf);
            close(pipefd[0]); // 关闭读取端
            exit(EXIT_SUCCESS);
        } else {
        
            // 父进程写入数据到管道
            close(pipefd[0]); // 关闭读取端
            char* msg = "Hello, child!";
            write(pipefd[1], msg, strlen(msg) + 1);
            close(pipefd[1]); // 关闭写入端
            exit(EXIT_SUCCESS);
        }
    }

在上述代码中，首先使用`pipe`函数创建了一个管道。然后使用`fork`函数创建了一个子进程。子进程使用`read`函数从管道中读取数据，父进程使用`write`函数将数据写入管道。

### 4. 兄弟进程间通信 ###

要实现兄弟进程之间的通信，可以使用命名管道（named pipe）或者共享内存（shared memory）来实现。

1.  使用命名管道（named pipe）：
    
     *  兄弟进程可以通过创建一个命名管道来进行通信。
     *  一个兄弟进程将数据写入命名管道，另一个兄弟进程从命名管道中读取数据。
     *  兄弟进程需要使用相同的命名管道名称来进行通信。
     *  可以使用`mkfifo`函数创建命名管道，使用`open`函数打开管道进行读写操作。
2.  使用共享内存（shared memory）：
    
     *  兄弟进程可以通过创建一个共享内存区域来进行通信。
     *  一个兄弟进程将数据写入共享内存，另一个兄弟进程从共享内存中读取数据。
     *  兄弟进程需要使用相同的共享内存标识符来进行通信。
     *  可以使用`shmget`函数创建共享内存，使用`shmat`函数将共享内存附加到进程的地址空间中进行读写操作。

***下面是一个使用命名管道的示例代码，演示了兄弟进程之间的通信过程：***

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <string.h>
    #include <fcntl.h>
    #include <sys/stat.h>
    
    int main() {
        
        pid_t pid;
        char buf[1024];
        const char* fifoName = "/tmp/myfifo";
    
        // 创建命名管道
        mkfifo(fifoName, 0666);
    
        // 创建子进程
        pid = fork();
        if (pid == -1) {
        
            perror("fork");
            exit(EXIT_FAILURE);
        }
    
        if (pid == 0) {
        
            // 子进程从命名管道中读取数据
            int fd = open(fifoName, O_RDONLY);
            read(fd, buf, sizeof(buf));
            printf("Received message from sibling: %s\n", buf);
            close(fd);
            exit(EXIT_SUCCESS);
        } else {
        
            // 父进程向命名管道中写入数据
            int fd = open(fifoName, O_WRONLY);
            char* msg = "Hello, sibling!";
            write(fd, msg, strlen(msg) + 1);
            close(fd);
            exit(EXIT_SUCCESS);
        }
    }

在上述代码中，首先使用`mkfifo`函数创建了一个命名管道。然后使用`fork`函数创建了一个子进程。子进程使用`open`函数打开命名管道并从中读取数据，父进程使用`open`函数打开命名管道并向其中写入数据。

### 5. fifo函数 ###

下面是一个使用`mkfifo`和`open`函数的示例代码，演示了兄弟进程之间的通信过程：

### 6. fifo实现血缘关系进程间通信 ###

下面是一个使用命名管道实现非血缘关系进程间通信的示例代码：

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <string.h>
    #include <fcntl.h>
    #include <sys/stat.h>
    
    int main() {
        
        pid_t pid;
        char buf[1024];
        const char* fifoName = "/tmp/myfifo";
    
        // 创建命名管道
        mkfifo(fifoName, 0666);
    
        // 创建子进程
        pid = fork();
        if (pid == -1) {
        
            perror("fork");
            exit(EXIT_FAILURE);
        }
    
        if (pid == 0) {
        
            // 子进程向命名管道中写入数据
            int fd = open(fifoName, O_WRONLY);
            char* msg = "Hello, sibling!";
            write(fd, msg, strlen(msg) + 1);
            close(fd);
            exit(EXIT_SUCCESS);
        } else {
        
            // 父进程从命名管道中读取数据
            int fd = open(fifoName, O_RDONLY);
            read(fd, buf, sizeof(buf));
            printf("Received message from sibling: %s\n", buf);
            close(fd);
            exit(EXIT_SUCCESS);
        }
    }

在上述代码中，首先使用`mkfifo`函数创建了一个命名管道。然后使用`fork`函数创建了一个子进程。子进程使用`open`函数打开命名管道并向其中写入数据，父进程使用`open`函数打开命名管道并从中读取数据。

### 7. 管道的特性和限制 ###

管道作为一种进程间通信方式，具有以下特性和限制：

*  管道是半双工的，即数据只能在一个方向上流动。
 *  管道是有限长度的，一旦写满了数据，继续写入会被阻塞，直到有进程读取数据后才能继续写入。
 *  管道只能在有亲缘关系的进程之间使用，即父子进程或者兄弟进程之间。

### 8. 总结 ###

1.  `fifo`函数：在C标准库中没有名为`fifo`的函数。
2.  命名管道（FIFO）：命名管道是一种特殊的文件，可以在文件系统中创建，并且可以被不同的进程打开和读写。使用`mkfifo`函数可以创建命名管道。
3.  兄弟进程间通信：兄弟进程是指由同一个父进程创建的多个子进程。兄弟进程间通信可以使用命名管道实现，其中一个进程向命名管道写入数据，另一个进程从命名管道读取数据。
4.  非血缘关系进程间通信：非血缘关系的进程是指没有共同的父进程的进程。非血缘关系进程间通信同样可以使用命名管道实现，其中一个进程向命名管道写入数据，另一个进程从命名管道读取数据。

[969be700a4ec4b7d8802a40ccfda67c2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/f7c919e67e744a1e8fd8ea3589d86693.png