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

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

【Linux操作系统】详解Linux系统编程中的管道进程通信_第1张图片

文章目录

    • 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 
#include 
#include 
#include 

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 
#include 
#include 
#include 

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 
#include 
#include 
#include 
#include 
#include 

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函数

下面是一个使用mkfifoopen函数的示例代码,演示了兄弟进程之间的通信过程:

#include 
#include 
#include 
#include 
#include 
#include 

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函数打开命名管道并向其中写入数据。

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

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

#include 
#include 
#include 
#include 
#include 
#include 

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. 非血缘关系进程间通信:非血缘关系的进程是指没有共同的父进程的进程。非血缘关系进程间通信同样可以使用命名管道实现,其中一个进程向命名管道写入数据,另一个进程从命名管道读取数据。

你可能感兴趣的:(操作系统,linux,运维,服务器)