Linux-管道

最新推荐文章于 2023-06-29 18:41:34 发布

Nou_Camp

最新推荐文章于 2023-06-29 18:41:34 发布

阅读量462

点赞数

分类专栏： linux 文章标签： Linux-管道

本文链接：https://blog.csdn.net/Nou_Camp/article/details/73332255

版权

linux 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

管道-pipe
在Linux中，管道是一种使用非常频繁的通信机制。从本质上说，管道也是一种文件，但它又和一般的文件有所不同，管道可以克服使用文件进行通信的两个问题，具体表现为：
· 限制管道的大小。实际上，管道是一个固定大小的缓冲区。在Linux中，该缓冲区的大小为1页，即4K字节，使得它的大小不像文件那样不加检验地增长。使用单个固定缓冲区也会带来问题，比如在写管道时可能变满，当这种情况发生时，随后对管道的write()调用将默认地被阻塞，等待某些数据被读取，以便腾出足够的空间供write()调用写。
· 读取进程也可能工作得比写进程快。当所有当前进程数据已被读取时，管道变空。当这种情况发生时，一个随后的read()调用将默认地被阻塞，等待某些数据被写入，这解决了read()调用返回文件结束的问题。注意：从管道读数据是一次性操作，数据一旦被读，它就从管道中被抛弃，释放空间以便写更多的数据。
管道具有以下特点：
1) 管道是半双工的，数据只能单向流动；需要相互通信时，就要建立两个管道。
2) 单独构成一种独立的文件系统，并且只存在于内存中。
3) 数据的读出和写入都是单向的：一个进程向管道中写的数据被管道另一端的进程读出。写入的数据每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据。
管道创建
管道是⼀种最基本的IPC机制,由pipe函数创建:
头文件：unistd.h
int pipe(int filedes[2]);
调⽤pipe函数时在内核中开辟⼀块缓冲区(称为管道)⽤于通信,它有⼀个读端⼀个写端,然后通过filedes参数传出给用户程序两个文件描述符,filedes[0]指向管道的读端,filedes[1]指向管道的写端(很好记,就像0是标准输⼊1是标准输出⼀样)。所以管道在用户程序看起来就像⼀个打开的文件,通过read(filedes[0]);或者write(filedes[1]);向这个⽂件读写数据其实是在读写内核缓冲区。 pipe函数调用成功返回0,调用失败返回-1。开辟了管道之后如何实现两个进程间的通信。
这里写图片描述
1.父进程调用pipe开辟管道,得到两个文件描述符指向管道的两端。
2.父进程调用fork创建子进程,那么子进程也有两个文件描述符指向同⼀管道。
3.父进程关闭管道读端,子进程关闭管道写端。父进程可以往管道里写,子进程可以从管道里读,管道是用环形队列实现的,数据从写端流入从读端流出,这样就实现了进程间通信。

/*使用pipe实现父进程向子进程发送信息*/
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>

 int main()
 {
     int fd[2];
     pipe(fd);//创建管道
     pid_t child;
     child=fork();//创建子进程
     char buff[15];//子进程用于读取的缓冲区
     char data[]="Hello!";//父进程用于写入的数据

      if(child==-1)//出错处理
      {
          perror("Child:");
          exit(1);
      }
      else if(child==0)//子进程从管道中读取信息到buff
      {
          close(fd[1]);
          if(read(fd[0],buff,15)>0)
          {
              printf("pid=%d\tppid=%d\t|%s\t<Read>\n",getpid(),getppid(),buff);
          }
          close(fd[0]);
          exit(0);
      }
      else//父进程通过data向管道中写入信息
      {
          close(fd[0]);
          if(write(fd[1],data,15)>0)
          {
              printf("pid=%d\tppid=%d\t|%s\t<Write>\n",getpid(),getppid(),data);

          }
          close(fd[1]);
          exit(0);
      }

       waitpid(child,NULL,0);//等待子进程结束
       exit(0);
 }

运行结果：
这里写图片描述
使⽤管道有⼀些限制:两个进程通过⼀个管道只能实现单向通信。比如上⾯的例子,父进程写子进程读,如果有时候也需要子进程写父进程读,就必须另开⼀个管道。
管道的读写端通过打开的文件描述符来传递,因此要通信的两个进程必须从它们的公共祖先那里继承管道文件描述符。
使⽤管道需要注意以下4种特殊情况：
1.如果所有指向管道写端的文件描述符都关闭了(管道写端的引⽤计数等于0),而仍然有进程从管道的读端读数据,那么管道中剩余的数据都被读取后,再次read会返回0,就像读到文件末尾⼀样。

#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/wait.h>
int main()
{
    int _pipe[2];
    int ret = pipe(_pipe);
    if(ret == -1){
        printf("create pipe error! errno code is : %d\n",errno);
        return 1;
    }
    pid_t id = fork();
    if( id < 0 ){
        printf("fork error!");
        return 2;
    }else if( id == 0 ){//child
    close(_pipe[0]);
    int i =0;
    char *_mesg_c=NULL;
    while(i<10){
        _mesg_c="i am child!";
        write(_pipe[1], _mesg_c, strlen(_mesg_c)+1);
        sleep(1);
        i++;
    }
    close(_pipe[1]);
    }else{ //father
        close(_pipe[1]);
        char _mesg[100];
        int j = 0;
        while(j<100){
            memset(_mesg, '\0', sizeof(_mesg));
            int ret = read(_pipe[0], _mesg, sizeof(_mesg));
            printf("%s : code is : %d\n",_mesg, ret);
            j++;
    }
    if ( waitpid(id, NULL, 0)< 0){
        return 3;
    }
    }
    return 0;
}

这里写图片描述

2.如果有指向管道写端的⽂件描述符没关闭(管道写端的引⽤计数⼤于0),而持有管道写端的进程也没有向管道中写数据,这时有进程从管道读端读数据,那么管道中剩余的数据都被读取后,再次read会阻塞,直到管道中有数据可读了才读取数据并返回。

#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/wait.h>
int main()
{
    int _pipe[2];
    int ret = pipe(_pipe);
    if(ret == -1){
        printf("create pipe error! errno code is : %d\n",errno);
        return 1;
    }
    pid_t id = fork();
    if( id < 0 ){
        printf("fork error!");
        return 2;
    }else if( id == 0 ){//child 
        close(_pipe[0]);
        int i =0;
        char *_mesg_c=NULL;
        while(i<20){
            if( i < 10 ){
                _mesg_c="i am child!";
                write(_pipe[1], _mesg_c, strlen(_mesg_c)+1);
    }
        sleep(1);
        i++;
    }
                                                                                close(_pipe[1]);
                                                                                }else{ //father
        close(_pipe[1]);
        char _mesg[100];
        int j = 0;
        while(j<20){
            memset(_mesg, '\0', sizeof(_mesg));
            int ret = read(_pipe[0], _mesg, sizeof(_mesg));
            printf("%s : code is : %d\n",_mesg, ret);
            j++;
    }
    if ( waitpid(id, NULL, 0)< 0){
        return 3;
        }
    }
     return 0;
}

这里写图片描述

3.如果所有指向管道读端的⽂件描述符都关闭了(管道读端的引用计数等于0),这时有进程向管道的写端write,那么该进程会收到信号SIGPIPE,通常会导致进程异常终止。

#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/wait.h>
int main()
{
    int _pipe[2];
    int ret = pipe(_pipe);
    if(ret == -1){
        printf("create pipe error! errno code is : %d\n",errno);
        return 1;
    }
    pid_t id = fork();
    if( id < 0 ){
                  printf("fork error!");
                          return 2;
    }else if( id == 0 ){ //child
        close(_pipe[0]);
        int i =0;
        char *_mesg_c=NULL;
        while(i<20){
            if( i < 10 ){
                _mesg_c="i am child!";
                write(_pipe[1], _mesg_c, strlen(_mesg_c)+1);
        }
        sleep(1);
        i++;
        }
    }else{ //father
        close(_pipe[1]);
        char _mesg[100];
        int j = 0;
        while(j<3){
        memset(_mesg, '\0', sizeof(_mesg));
        int ret = read(_pipe[0], _mesg, sizeof(_mesg));
        printf("%s : code is : %d\n",_mesg, ret);
        j++;
        }
                                                                                close(_pipe[0]);
    sleep(10);
    if ( waitpid(id, NULL, 0)< 0){
        return 3;
    }
    }
    return 0;
}

运行结果：
这里写图片描述

4.如果有指向管道读端的⽂件描述符没关闭(管道读端的引⽤计数大于0),而持有管道读端的进程也没有从管道中读数据,这时有进程向管道写端写数据,那么在管道被写满时再次write会阻塞,直到管道中有空位置了才写⼊数据并返回。
命名管道
管道的⼀个不⾜之处是没有名字，因此，只能⽤于具有亲缘关系的进程间通信，在命名管道（named pipe或FIFO）提出后，该限制得到了克服。 FIFO不同于管道之处在于它提供⼀个路径名与之关联，以FIFO的⽂件形式存储于⽂件系统中。命名管道是⼀个设备⽂件，因此，即使进程与创建FIFO的进程不存在亲缘关系，只要可以访问该路径，就能够通过FIFO相互通信。值得注意的是， FIFO(first input first output)总是按照先进先出的原则⼯作，第⼀个被写⼊的数据将⾸先从管道中读出。
命名管道的特点：
1) FIFO是作为一个特殊的设备文件存在；
2) 不同祖先进程的进程之间可以共享数据；
3) 使用完后FIFO将继续保存。

Nou_Camp

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Linux-管道

管道-pipe 在Linux中，管道是一种使用非常频繁的通信机制。从本质上说，管道也是一种文件，但它又和一般的文件有所不同，管道可以克服使用文件进行通信的两个问题，具体表现为： · 限制管道的大小。实际上，管道是一个固定大小的缓冲区。在Linux中，该缓冲区的大小为1页，即4K字节，使得它的大小不像文件那样不加检验地增长。使用单个固定缓冲区也会带来问题，比如在写管道时可能
复制链接

扫一扫

专栏目录