科技行者

行者学院 转型私董会 科技行者专题报道 网红大战科技行者

知识库

知识库 安全导航

至顶网安全频道Linux进程间通信:管道及有名管道

Linux进程间通信:管道及有名管道

  • 扫一扫
    分享文章到微信

  • 扫一扫
    关注官方公众号
    至顶头条

本文在详细讨论了管道和有名管道的通信机制的基础上,用实例对其读写规则进行了程序验证,这样做有利于增强读者对读写规则的感性认识,同时也提供了应用范例。

作者:郑彦兴 来源:巧巧读书 2010年4月17日

关键字: 进程 系统进程 进程管理 Linux

  • 评论
  • 分享微博
  • 分享邮件

在本页阅读全文(共2页)

  管道及有名管道

  在本系列序中作者概述了 linux进程间通信的几种主要手段。其中管道和有名管道是最早的进程间通信机制之一,管道可用于具有亲缘关系进程间的通信,有名管道克服了管道没有名字的限制,因此,除具有管道所具有的功能外,它还允许无亲缘关系进程间的通信。

  认清管道和有名管道的读写规则是在程序中应用它们的关键,本文在详细讨论了管道和有名管道的通信机制的基础上,用实例对其读写规则进行了程序验证,这样做有利于增强读者对读写规则的感性认识,同时也提供了应用范例。

  1、 管道概述及相关API应用

  1.1 管道相关的关键概念

  管道是Linux支持的最初UnixIPC形式之一,具有以下特点:

  管道是半双工的,数据只能向一个方向流动;需要双方通信时,需要建立起两个管道;

  只能用于父子进程或者兄弟进程之间(具有亲缘关系的进程);

  单独构成一种独立的文件系统:管道对于管道两端的进程而言,就是一个文件,但它不是普通的文件,它不属于某种文件系统,而是自立门户,单独构成一种文件系统,并且只存在与内存中。

  数据的读出和写入:一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾,并且每次都是从缓冲区的头部读出数据。

  1.2管道的创建:

  #include

  int pipe(int fd[2])

  该函数创建的管道的两端处于一个进程中间,在实际应用中没有太大意义,因此,一个进程在由pipe()创建管道后,一般再fork一个子进程,然后通过管道实现父子进程间的通信(因此也不难推出,只要两个进程中存在亲缘关系,这里的亲缘关系指的是具有共同的祖先,都可以采用管道方式来进行通信)。

  1.3管道的读写规则:

  管道两端可分别用描述字fd[0]以及fd[1]来描述,需要注意的是,管道的两端是固定了任务的。即一端只能用于读,由描述字fd[0]表示,称其为管道读端;另一端则只能用于写,由描述字fd[1]来表示,称其为管道写端。如果试图从管道写端读取数据,或者向管道读端写入数据都将导致错误发生。一般文件的I/O函数都可以用于管道,如close、read、write等等。

  从管道中读取数据:

  如果管道的写端不存在,则认为已经读到了数据的末尾,读函数返回的读出字节数为0;当管道的写端存在时,如果请求的字节数目大于PIPE_BUF,则返回管道中现有的数据字节数,如果请求的字节数目不大于PIPE_BUF,则返回管道中现有数据字节数(此时,管道中数据量小于请求的数据量);或者返回请求的字节数(此时,管道中数据量不小于请求的数据量)。注:(PIPE_BUF在include/linux/limits.h中定义,不同的内核版本可能会有所不同。Posix.1要求PIPE_BUF至少为512字节,red hat 7.2中为4096)。

  关于管道的读规则验证:

  * readtest.c *

  #include

  #include

  #include

  main()

  {

  int pipe_fd[2];

  pid_t pid;

  char r_buf[100];

  char w_buf[4];

  char* p_wbuf;

  int r_num;

  int cmd;

  memset(r_buf,0,sizeof(r_buf));

  memset(w_buf,0,sizeof(r_buf));

  p_wbuf=w_buf;

  if(pipe(pipe_fd)<0)

  {

  printf("pipe create error");

  return -1;

  }

  if((pid=fork())==0)

  {

  printf("");

  close(pipe_fd[1]);

  sleep(3);//确保父进程关闭写端

  r_num=read(pipe_fd[0],r_buf,100);

  printf( "read num is %d the data read from the pipe is %d",r_num,atoi(r_buf));

  close(pipe_fd[0]);

  exit();

  }

  else if(pid>0)

  {

  close(pipe_fd[0]);//read

  strcpy(w_buf,"111");

  if(write(pipe_fd[1],w_buf,4)!=-1)

  printf("parent write over");

  close(pipe_fd[1]);//write

  printf("parent close fd[1] over");

  sleep(10);

  }

  }

  程序输出结果:

  * parent write over

  * parent close fd[1] over

  * read num is 4 the data read from the pipe is 111

  附加结论:管道写端关闭后,写入的数据将一直存在,直到读出为止。

  向管道中写入数据:

  向管道中写入数据时,linux将不保证写入的原子性,管道缓冲区一有空闲区域,写进程就会试图向管道写入数据。如果读进程不读走管道缓冲区中的数据,那么写操作将一直阻塞。

  注:只有在管道的读端存在时,向管道中写入数据才有意义。否则,向管道中写入数据的进程将收到内核传来的SIFPIPE信号,应用程序可以处理该信号,也可以忽略(默认动作则是应用程序终止)。对管道的写规则的验证1:写端对读端存在的依赖性

  #include

  #include

  main()

  {

  int pipe_fd[2];

  pid_t pid;

  char r_buf[4];

  char* w_buf;

  int writenum;

  int cmd;

  memset(r_buf,0,sizeof(r_buf));

  if(pipe(pipe_fd)<0)

  {

  printf("pipe create error");

  return -1;

  }

  if((pid=fork())==0)

  {

  close(pipe_fd[0]);

  close(pipe_fd[1]);

  sleep(10);

  exit();

  }

  else if(pid>0)

  {

  sleep(1); //等待子进程完成关闭读端的操作

  close(pipe_fd[0]);//write

  w_buf="111";

  if((writenum=write(pipe_fd[1],w_buf,4))==-1)

  printf("write to pipe error");

  else

  printf("the bytes write to pipe is %d ", writenum);

  close(pipe_fd[1]);

  }

  }

  则输出结果为: Broken pipe,原因就是该管道以及它的所有fork()产物的读端都已经被关闭。如果在父进程中保留读端,即在写完pipe后,再关闭父进程的读端,也会正常写入pipe,读者可自己验证一下该结论。因此,在向管道写入数据时,至少应该存在某一个进程,其中管道读端没有被关闭,否则就会出现上述错误(管道断裂,进程收到了SIGPIPE信号,默认动作是进程终止)对管道的写规则的验证2:linux不保证写管道的原子性验证

  #include

  #include

  #include

  main(int argc,char**argv)

  {

  int pipe_fd[2];

  pid_t pid;

  char r_buf[4096];

  char w_buf[4096*2];

  int writenum;

  int rnum;

  memset(r_buf,0,sizeof(r_buf));

  if(pipe(pipe_fd)<0)

  {

  printf("pipe create error");

  return -1;

  }

  if((pid=fork())==0)

  {

  close(pipe_fd[1]);

  while(1)

  {

  sleep(1);

  rnum=read(pipe_fd[0],r_buf,1000);

  printf("child: readnum is %d",rnum);

  }

  close(pipe_fd[0]);

  exit();

  }

  else if(pid>0)

  {

  close(pipe_fd[0]);//write

  memset(r_buf,0,sizeof(r_buf));

  if((writenum=write(pipe_fd[1],w_buf,1024))==-1)

  printf("write to pipe error");

  else

  printf("the bytes write to pipe is %d ", writenum);

  writenum=write(pipe_fd[1],w_buf,4096);

  close(pipe_fd[1]);

  }

  }

  输出结果:

  the bytes write to pipe 1000

  the bytes write to pipe 1000 //注意,此行输出说明了写入的非原子性

  the bytes write to pipe 1000

  the bytes write to pipe 1000

  the bytes write to pipe 1000

  the bytes write to pipe 120 //注意,此行输出说明了写入的非原子性

  the bytes write to pipe 0

  the bytes write to pipe 0

  ......

  结论:

  写入数目小于4096时写入是非原子的!

  如果把父进程中的两次写入字节数都改为5000,则很容易得出下面结论:

  写入管道的数据量大于4096字节时,缓冲区的空闲空间将被写入数据(补齐),直到写完所有数据为止,如果没有进程读数据,则一直阻塞。

  1.4管道应用实例:

  实例一:用于shell

  管道可用于输入输出重定向,它将一个命令的输出直接定向到另一个命令的输入。比如,当在某个shell程序(Bourne shell或C shell等)键入who│wc -l后,相应shell程序将创建who以及wc两个进程和这两个进程间的管道。考虑下面的命令行:

  $kill -l 运行结果见附一。

  $kill -l | grep SIGRTMIN 运行结果如下:

  30) SIGPWR 31) SIGSYS 32) SIGRTMIN 33) SIGRTMIN+1

  34) SIGRTMIN+2 35) SIGRTMIN+3 36) SIGRTMIN+4 37) SIGRTMIN+5

  38) SIGRTMIN+6 39) SIGRTMIN+7 40) SIGRTMIN+8 41) SIGRTMIN+9

  42) SIGRTMIN+10 43) SIGRTMIN+11 44) SIGRTMIN+12 45) SIGRTMIN+13

  46) SIGRTMIN+14 47) SIGRTMIN+15 48) SIGRTMAX-15 49) SIGRTMAX-14

  实例二:用于具有亲缘关系的进程间通信

  下面例子给出了管道的具体应用,父进程通过管道发送一些命令给子进程,子进程解析命令,并根据命令作相应处理。

  #include

  #include

  main()

  {

  int pipe_fd[2];

  pid_t pid;

  char r_buf[4];

  char** w_buf[256];

  int childexit=0;

  int i;

  int cmd;

  memset(r_buf,0,sizeof(r_buf));

  if(pipe(pipe_fd)<0)

  {

  printf("pipe create error");

  return -1;

  }

  if((pid=fork())==0)

  //子进程:解析从管道中获取的命令,并作相应的处理

  {

  printf("");

  close(pipe_fd[1]);

  sleep(2);

  while(!childexit)

  {

  read(pipe_fd[0],r_buf,4);

  cmd=atoi(r_buf);

  if(cmd==0)

  {

  printf("child: receive command from parent over now child process exit");

  childexit=1;

  }

  else if(handle_cmd(cmd)!=0)

  return;

  sleep(1);

  }

  close(pipe_fd[0]);

  exit();

  }

  else if(pid>0)

  //parent: send commands to child

  {

  close(pipe_fd[0]);

  w_buf[0]="003";

  w_buf[1]="005";

  w_buf[2]="777";

  w_buf[3]="000";

  for(i=0;i<4;i++)

  write(pipe_fd[1],w_buf,4);

  close(pipe_fd[1]);

  }

  }

  //下面是子进程的命令处理函数(特定于应用):

  int handle_cmd(int cmd)

  {

  if((cmd<0)||(cmd>256))

  //suppose child only support 256 commands

  {

  printf("child: invalid command ");

  return -1;

  }

  printf("child: the cmd from parent is %d", cmd);

  return 0;

  }

  1.5管道的局限性

  管道的主要局限性正体现在它的特点上:

  只支持单向数据流;

  只能用于具有亲缘关系的进程之间;

  没有名字;

  管道的缓冲区是有限的(管道制存在于内存中,在管道创建时,为缓冲区分配一个页面大小);

  管道所传送的是无格式字节流,这就要求管道的读出方和写入方必须事先约定好数据的格式,比如多少字节算作一个消息(或命令、或记录)等等。

    • 评论
    • 分享微博
    • 分享邮件
    邮件订阅

    如果您非常迫切的想了解IT领域最新产品与技术信息,那么订阅至顶网技术邮件将是您的最佳途径之一。

    重磅专题
    往期文章
    最新文章