【Linux】—— 匿名管道

匿名管道（Anonymous Pipes）：匿名管道是最基本的管道类型，在命令行中使用竖线符号（|）来创建。它只能用于相关进程之间的通信，父进程与子进程之间或者同一管道链中的进程之间。
命名管道（Named Pipes）：命名管道（也称为FIFO）是一种有名字的管道，由mkfifo命令创建。它可以在磁盘上持久存在，并允许无关的进程之间进行通信。多个进程可以通过读取和写入相同的命名管道来进行数据交换。

1、匿名管道?

匿名管道是一种在进程间进行通信的机制，通常用于父子进程之间或者通过衍生的进程之间传递数据。匿名管道是一种单向通信机制，即数据只能从一个进程流向另一个进程。

💨?接下来介绍匿名管道的一些关键特性：

1??创建匿名管道（大家可以通过man手册进行查询）

匿名管道通过系统调用（例如，在Unix/Linux中使用pipe函数）创建；
创建管道时，操作系统会返回两个文件描述符，一个用于读取（读文件描述符），另一个用于写入（写文件描述符）

2??下面是一个简单的C语言示例，演示了如何使用匿名管道在父子进程之间进行通信：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#define BUFFER_SIZE 25

int main() {
    int pipefd[2]; // 用于存放管道两端文件描述符的数组
    pid_t pid;
    char message[BUFFER_SIZE] = "Hello, child process!";

    // 创建管道
    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    // 创建子进程
    pid = fork();

    if (pid < 0) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid > 0) { // 父进程
        close(pipefd[0]); // 关闭用于读的文件描述符

        // 向管道写入消息
        write(pipefd[1], message, strlen(message) + 1);

        // 关闭用于写的文件描述符
        close(pipefd[1]);

        printf("Parent process: Message sent to child.\n");
    } else { // 子进程
        close(pipefd[1]); // 关闭用于写的文件描述符

        // 从管道读取消息
        char received_message[BUFFER_SIZE];
        read(pipefd[0], received_message, sizeof(received_message));

        // 关闭用于读的文件描述符
        close(pipefd[0]);

        printf("Child process: Received message - %s\n", received_message);
    }

    return 0;
}

2、场景分类

💨当读的一方?read 完所有的管道数据，如果写的一方不往管道里面发送数据，此时就只能等待：

 int main()
 {
      // 任何一种任何一种进程间通信中，一定要 先 保证不同的进程之间看到同一份资源
      int pipefd[2] = {0};
      //1. 创建管道
      int n = pipe(pipefd);
      if(n < 0)
      {
          std::cout << "pipe error, " << errno << ": " << strerror(errno) << std::endl;
          return 1;
      }
      std::cout << "pipefd[0]: " << pipefd[0] << std::endl; // 
      std::cout << "pipefd[1]: " << pipefd[1] << std::endl; // 
      
      //2. 创建子进程
      pid_t id = fork();
      assert(id != -1); //正常应该用判断，我这里就断言：意料之外用if，意料之中用assert
  
      if(id == 0)    // 子进程
      {
          //3. 关闭不需要的fd，让父进程进行读取，让子进程进行写入                                                  
          close(pipefd[0]);
  
            //4. 开始通信 -- 结合某种场景
           const std::string namestr = "hello， 我是子进程";
           int cnt = 1;
           char buffer[1024];
  
           while(true)
           {
              snprintf(buffer, sizeof buffer, "%s, 计数器: %d, 我的PID: 
                       %d",namestr.c_str(), cnt++, getpid());
              write(pipefd[1], buffer, strlen(buffer));
              sleep(10);
           }
                                                                                                                   
            close(pipefd[1]);
            exit(0);
  
        }
  
       //父进程
      //3. 关闭不需要的fd，让父进程进行读取，让子进程进行写入
      close(pipefd[1]);
  
      //4. 开始通信 -- 结合某种场景
      char buffer[1024];
      while(true)
      {
           int n = read(pipefd[0], buffer, sizeof(buffer) - 1);
          if(n > 0)
          {
              buffer[n] = '\0';
              std::cout << "我是父进程, child give me message: " << buffer << std::endl;
          }
      }
  
      close(pipefd[0]);
      return 0;
  }

💨当写的一方不往管道里面 write 数据，而读的一方此时不读，当管道写满之后就不能在继续写数据（即管道有大小限制）：

输出结果：

💨当此时关闭了写数据的一方，读取完毕管道数据。如果在继续读取的话，就会 read 返回0，表明读到文件结尾。

输出结果：

💨当写端一直写，读端关闭，此时就没有意义，OS不会维护无意义、低效率的事件，会通过 13号?信号来杀死一直写入的进程：

输出结果：

?3、管道读写规则

🔥 当没有数据可读时：

O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。
O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。

🔥 当管道满的时候：

O_NONBLOCK disable： write调用阻塞，直到有进程读走数据
O_NONBLOCK enable：调用返回-1，errno值为EAGAIN

🔥 如果所有管道写端对应的文件描述符被关闭，则read 返回 0；

🔥 如果所有管道读端对应的文件描述符被关闭，则write 操作会产生信号 SIGPIPE , 进而可能导致 write 进程退出；

🔥 当要写入的数据量不大于 PIPE_BUF 时， linux 将保证写入的原子性；

🔥 当要写入的数据量大于PIPE_BUF 时， linux 将不再保证写入的原子性。

4、管道特点

通过上述，简单总结一下管道有哪些特点：

只能用于具有共同祖先的进程（具有亲缘关系的进程）之间进行通信；通常，一个管道由一个进程创建，然后该进程调用fork，此后父、子进程之间就可应用该管道。
管道提供流式服务；
一般而言，进程退出，管道释放，所以管道的生命周期随进程
一般而言，内核会对管道操作进行同步与互斥
管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道

（四）总结

接下来，简单总结一下本期关于“匿名管道”的全部知识！！！

使用匿名管道可以方便地在父子进程之间传递数据，但也有一些限制，如只能用于具有亲缘关系的进程间通信，无法用于无关进程之间的通信；
此外，管道的容量有限，如果写入速度超过读取速度，可能会导致阻塞；
在实际使用中，可以根据需求选择其他更复杂的进程间通信机制，如命名管道、共享内存或消息队列等。

以上便是本期关于匿名管道的全部内容了，感谢大家的观看与支持！！！

文章来源:https://blog.csdn.net/m0_56069910/article/details/133530956
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！