您现在的位置是:首页 >技术教程 >进程通信 — 管道网站首页技术教程

进程通信 — 管道

布逆呲没来 2024-06-17 11:26:54
简介进程通信 — 管道

进程通信

进程之间可能会存在特定的协同工作场景。

一个进程要把自己的数据交付给另一个进程,让其进行出来处理。而一个进程把自己的数据交付给另一个进程的动作,就叫做进程通信。

前提

进程是具有独立性的,交互数据的成本一定很高(一个进程看不到另一个进程的资源)。因此要完成进程间通信,不能只在应用层解决,需要操作系统干预进行解决。即操作系统要设计通信方式。

进程要通信,因其独立性,必须得先看到一份公共的资源(里面有相关数据等)。这里的公共的资源是一段属于操作系统的内存。因此,进程间通信的前提本质,其实是由OS参与,提供一份所有通信进程能看到的公共资源

这段操作系统所提供的内存,可能以文件方式提供,也可能以队列的方式,也可能提供的就是原始的内存块……这也就是通信方式有很多种的原因。

总的来说,进程通信要解决的最根本的问题就是,如何让两个不同的进程看到一份公共资源

进程间通信的目的

  • 数据传输:一个进程需要将它的数据发送给另一个进程
  • 资源共享:多个进程之间共享同样的资源。
  • 通知事件:一个进程需要向另一个或一组进程发送消息,通知它(它们)发生了某种事件(如进程终止时要通知父进程)。
  • 进程控制:有些进程希望完全控制另一个进程的执行(如Debug进程),此时控制进程希望能够拦截另一个进程的所有陷入和异常,并能够及时知道它的状态改变。

进程间通信发展

  • 管道
  • System V进程间通信
  • POSIZX进程间通信

进程间通信分类

管道

  • 匿名管道pipe
  • 命名管道

System V IPC

  • System V 消息队列
  • System V 共享内存
  • System V 信号量

POSIX IPC

  • 消息队列
  • 共享内存
  • 信号量
  • 互斥量
  • 条件变量
  • 读写锁

管道

认识管道

  • 管道是Unix中最古老的进程间通信的形式。
  • 我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”。

image-20230516164633306

匿名管道

#include <unistd.h>
功能:创建一无名管道
原型
int pipe(int fd[2]);
参数
fd:文件描述符数组,其中fd[0]表示读端, fd[1]表示写端
返回值:成功返回0,失败返回错误代码

父子进程是两个独立的进程,因此父子通信也属于进程通信的一种。匿名管道就是基于父子。

匿名管道的本质就是:通过子进程继承父进程资源的特性,达到一个让不同的进程看到同一份资源。

image-20230516163105498

站在文件描述符角度,深度理解管道

  • 分别以读方式和写方式打开文件

image-20230516165400681

管道是一个只能单向通信的通信信道,若需双向通信,则需建立两个管道。

image-20230516165958276

image-20230516170107193

//从键盘读取数据,写入管道,读取管道,写到屏幕
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
int main(){
  int pipefd[2] = {0};
  if(pipe(pipefd) != 0){
    perror("pipe error");
    return 1;
  }
  //pipefd[0] pipefd[1]
  //0(嘴):读取端  1(笔):写入端
  printf("pipefd[0]: %d
", pipefd[0]);
  printf("pipefd[1]: %d
", pipefd[1]);

  //我们想让父进程进行读取,子进程写入
  if(fork() == 0){
    //子进程
    close(pipefd[0]); //子进程写入,故关闭读取端
    
    const char *msg = "hahaha!";
    while(1){
      //pipe里面只要有缓冲区,就一直写入
      write(pipefd[1], msg, strlen(msg)); //strlen(msg)+1 ?? 不需要 
不被写入
      //sleep(1);
    }
    exit(0);
  }
  //父进程
  close(pipefd[1]); //父进程读取,故关闭写入端
  while(1){
    //没有让父进程sleep->子进程写得慢,父进程读得快
    //让父进程sleep,只要有数据,就可以一直读取
    sleep(1);
    char buffer[64] = {0};
    ssize_t s = read(pipefd[0], buffer, sizeof(buffer)-1);//如果read的返回值是0,意味子进程关闭文件描述符
    if(s == 0){
      printf("child quit...
");
      break;
    }
    else if(s > 0){
      buffer[s] = 0;
      printf("child say# %s
", buffer);
    }else{
      printf("read error...
");
      break;
      }
  }
  return 0;
}

//pipefd[2]:是一个输出性参数!我们想通过这个参数读取到打开的两个fd
//int pipe(int pipefd[2]); 成功返回0,失败返回-1

image-20230516192207034

管道读取规则

  • 若只让子进程写入,父进程不读只休眠

image-20230516201946951
可以发现,子进程在写入到65536时停止写入。65526/1024 = 64 (1024字节 = 1KB)

写满64KB,writer就不再写入,这是因为管道有大小。此处可以知道,云服务器上管道最大容量为64KB。image-20230516202145160

当writer写满的时候,为什么不写了?不继续覆盖?因为要让reader来读。

停止写入的本质是等reader来读。

  • 若是让父进程每休眠10秒后读一个字符,通过实践可以发现,子进程不会继续写入,每休眠10秒后读64字符,子进程依旧不会继续写入……而当每休眠10秒后读的字符增加到1024个字符时(足够多),子进程会继续写入。

这就是管道自带的同步机制。

读写规则

当没有数据可读时

  • 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将不再保证写入的原子性。

管道特点

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

为了解决匿名管道只能父子通信,引入了命名管道。

命名管道

  • 管道应用的一个限制就是只能在具有共同祖先(具有亲缘关系)的进程间通信。
  • 如果我们想在不相关的进程之间交换数据,可以使用FIFO文件来做这项工作,它经常被称为命名管道。
  • 命名管道是一种特殊类型的文件
  • 通过man手册查看命名管道的定义

image-20230517195425139

  • 命名管道的命令行操作image-20230516215051864

  • 创建命名管道

    //server.h
    #include <stdio.h>
    #include <sys/stat.h>
    #include <sys/types.h>
    
    #define MY_FIFO "./fifo"
    int main(){
      umask(0);
      //创建一个命名管道,如果失败返回1
      if(mkfifo(MY_FIFO, 0666) < 0){
        perror("mkfifo");
        return 1;
      }
      return 0;
    }
    

    一旦具有了命名管道,此时,我们只需要让通信双方按照文件操作即可。

下面这个例子就是用命名管道实现server&client通信

  • comm.h

    #include <stdio.h>
    #include <string.h>
    #include <sys/stat.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <fcntl.h>
    #include <unistd.h>
    #define MY_FIFO "./fifo"
    
  • server.c

    #include "comm.h"
    int main(){
      umask(0);
      if(mkfifo(MY_FIFO, 0666) < 0){
        perror("mkfifo");
        return 1;
      }
      //只需要文件操作即可
      int fd = open(MY_FIFO, O_RDONLY);
      if(fd < 0){
        perror("open");
        return 2;
      }
      //业务逻辑,可以进行对应的读写了
      while(1){
        char buffer[64] = {0};
        ssize_t s = read(fd, buffer, sizeof(buffer)-1);
        if(s > 0){
          //success
          buffer[s] = 0;
          printf("client# %s
    ", buffer);
        }
        else if( s == 0){
          //peer close
          printf("client quit...
    ");
          break;
        }else{
          //error
          perror("read");
          break;
        }
      }
      close(fd);
      return 0;
    }
    
  • client.c

    #include "comm.h"
    int main(){
      //无需再创建fifo,只需获取即可
      int fd = open(MY_FIFO, O_WRONLY);
      if(fd < 0){
        perror("open");
        return 1;
      }
      //业务逻辑
      while(1){
        printf("请输入# ");
          fflush(stdout);
        char buffer[64] = {0};
        //先把数据从标准输入拿到我们的client进程内部
        ssize_t s = read(0, buffer, sizeof(buffer)-1); //使用的系统调用,/n也是输入字符的一部分,故需要s-1
        if(s > 0){
          buffer[s-1] = 0;
          printf("%s
    ", buffer);
    
          //拿到了数据
          write(fd, buffer, strlen(buffer));
        }
      }
      close(fd);
      return 0;
    }
    
  • 运行效果:

    image-20230517215318852

也可再添加其他代码,实现通过client控制server

server.c

#include "comm.h"
#include <sys/wait.h>
int main(){

  umask(0);
  if(mkfifo(MY_FIFO, 0666) < 0){
    perror("mkfifo");
    return 1;
  }
  //只需要文件操作即可
  int fd = open(MY_FIFO, O_RDONLY);
  if(fd < 0){
    perror("open");
    return 2;
  }
  //业务逻辑,可以进行对应的读写了
  while(1){
    char buffer[64] = {0};
    ssize_t s = read(fd, buffer, sizeof(buffer)-1);
    if(s > 0){
      //success
      buffer[s] = 0;
      if(strcmp(buffer, "show") == 0){

        if(fork() == 0){
          execl("/usr/bin/ls", "ls", "-l", NULL);
          exit(1);
        }
      waitpid(-1, NULL, 0);
      }    
      else if(strcmp(buffer, "run") == 0){
        if(fork() == 0){
          execl("/usr/bin/sl", "sl", NULL);
        } 
        waitpid(-1, NULL, 0);
      }
      else{
        printf("client# %s
", buffer);
      }
    }
    else if( s == 0){
      //peer close
      printf("client quit...
");
      break;
    }else{
      //error
      perror("read");
      break;
    }
  }
  close(fd);
  return 0;
}
  • 运行效果

    image-20230517222926201

    image-20230517223027613

命名管道的打开规则

如果当前打开操作是为读而打开FIFO时

  • O_NONBLOCK disable:阻塞直到有相应进程为写而打开该FIFO
  • O_NONBLOCK enable:立刻返回成功

如果当前打开操作是为写而打开FIFO时

  • O_NONBLOCK disable:阻塞直到有相应进程为读而打开该FIFO
  • O_NONBLOCK enable:立刻返回失败,错误码为ENXIO

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

  • 匿名管道由pipe函数创建并打开。
  • 命名管道由mkfifo函数创建,打开用open
  • FIFO(命名管道)与pipe(匿名管道)之间唯一的区别在它们创建与打开的方式不同,一但这些工作完成之后,它们具有相同的语义。
    片转存中…(img-JdQaFpMg-1684334867775)]

命名管道的打开规则

如果当前打开操作是为读而打开FIFO时

  • O_NONBLOCK disable:阻塞直到有相应进程为写而打开该FIFO
  • O_NONBLOCK enable:立刻返回成功

如果当前打开操作是为写而打开FIFO时

  • O_NONBLOCK disable:阻塞直到有相应进程为读而打开该FIFO
  • O_NONBLOCK enable:立刻返回失败,错误码为ENXIO

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

  • 匿名管道由pipe函数创建并打开。
  • 命名管道由mkfifo函数创建,打开用open
  • FIFO(命名管道)与pipe(匿名管道)之间唯一的区别在它们创建与打开的方式不同,一但这些工作完成之后,它们具有相同的语义。
风语者!平时喜欢研究各种技术,目前在从事后端开发工作,热爱生活、热爱工作。