管道通信介绍

最新推荐文章于 2024-08-17 16:48:31 发布

学不会！！！！！

最新推荐文章于 2024-08-17 16:48:31 发布

阅读量521

点赞数 18

文章标签： linux 运维服务器

本文链接：https://blog.csdn.net/x5856856/article/details/140840683

版权

1、管道简介

管道是Linux中进程间通信的一种方式，它把一个程序的输出直接连接到另一个程序的输入。linux的管道主要包括无名管道和有名管道。

（1）无名管道

无名管道是linux中管道通信的一种原始方法，它具有如下特点：

a、它只能用于具有亲缘关系的进程之间的通信(也就是父子进程或者兄弟进程之间)。

b、它是一个半双工的通信模式，具有固定的读端和写端。

c、管道也可以看成是一种特殊的文件，对于它的读写也可以使用普通的read()、write()等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。

（2）有名管道

有名管道（FIFO）是对无名管道的一种改进。它具有如下特点：

a、它可以使互不相关的两个进程实现彼此通信。

b、该管道可以通过路径名来指出，并且在文件系统中是可见的。在建立了管道之后，两个进程就可以把它当作普通文件一样进行读写操作，使用非常方便。

c、FIFO 严格地遵循先进先出规则，对管道及 FIFO 的读操作总是从开始处返回数据，对它们的写操作则把数据添加到末尾，它们不支持如lseek()等文件定位操作。

2、无名管道系统调用

（1）管道创建与关闭说明

管道是基于文件描述符的通信方式，当一个管道建立时，它会创建两个文件描述符fd[0]和fd[1]，其中fd[0]固定用于读管道，而fd[1]固定用于写管道，如下图所示，这样就构成了一个半双工的通道。

管道关闭时只需将这两个文件描述符关闭即可，可使用close()函数逐个关闭各个文件描述符。

（2）管道创建函数

创建管道可以用pipe()来实现，pipe()语法如下：

#include<unistd.h>

int pipe(int fd[2])

fd[2]:管道的两个文件描述符，之后就可以直接操作这两个文件描述符

函数返回值：成功0，出错-1

（3）管道读写说明

用 pipe()函数创建的管道两端处于一个进程中，由于管道是主要用于在不同进程间通信的，因此这在实际应用中没有太大意义。实际上，通常先是创建一个管道，再调用fork()函数创建一子进程，该子进程会继承父进程所创建的管道，这时，父子进程管道的文件描述符对应关系如下图所示。

此时的关系看似非常复杂，实际上却已经给不同进程之间的读写创造了很好的条件。父子进程分别拥有自己的读写通道，为了实现父子进程之间的读写，只需把无关的读端或写端的文件描述符关闭即可。例如在下图中将父进程的写端 fd[1]和子进程的读端 fd[0]关闭。此时，父子进程之间就建立起了一条“子进程写入父进程读取”的通道。

同样，也可以关闭父进程的 fd[0]和子进程的fd[1],这样就可以建立一条“父进程写入子进程读取”的通道。另外，父进程还可以创建多个子进程，各个子进程都继承了相应的fd[0]和 fd[1]，这时，只需要关闭相应端口就可以建立起各子进程之间的通道。

（4）管道读写注意事项

① 只有在管道的读端存在时，向管道写人数据才有意义。否则，向管道写入数据的进程将收
到内核传来的 SIGPIPE信号(通常为Broken pipe 错误 )。

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

③ 父子进程在运行时，它们的先后次序并不能保证，因此，在为了保证父子进程已经关闭了相应的文件描述符，可在两个进程中调用 sleep()函数，当然这种调用不是很好的解决方法，更好的解决方法可以采用进程之间的同步与互斥机制。

（5）使用实例

在本例中，首先创建管道，之后父进程使用fork()函数创建子进程，然后通过关闭父进程的读描述符和子进程的写描述符，建立起它们之间的管道通信。

#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#define MAX_DATA_LEN 256
#define DELAY_TIME 1

int main()
{
    pid_t pid;
    int pipe_fd[2];
    char buf[MAX_DATA_LEN];
    const char data[]="pipe test program";
    int real_read,real_write;

    memset((void*)buf,0,sizeof(buf));//将256个字节空间buf数组初始化为0
    if(pipe(pipe_fd)<0)//创建一管道
    {
        printf("pipe create error");
        exit(1);
    }
    if((pid=fork())==0)//创建一子进程，返回值为0代表子进程
    {
        //子进程关闭写描述符，并通过使子进程暂停等待父进程已关闭相应的读描述符
        close(pipe_fd[1]);
        sleep(DELAY_TIME*3);
        if((real_read=read(pipe_fd[0],buf,MAX_DATA_LEN))>0)
        {
            printf("%d bytes read from the pipe is '%s'\n",real_read,buf);
        }
        close(pipe_fd[0]);//关闭子进程读描述符
        exit(0);
    }
    else if(pid>0)
    {
        //父进程关闭读描述符，并通过使父进程暂停等待子进程已关闭相应的写描述符
        close(pipe_fd[0]);
        sleep(DELAY_TIME);
        if((real_write=write(pipe_fd[1],data,strlen(data)))!=-1)
        {
            printf("parent wrote %d bytes:'%s'\n",real_read,data);
        }
        close (pipe_fd[1]);//关闭父进程写描述符
        waitpid(pid,NULL,0);//收集子进程退出信息
        exit(0);

    }

}

运行结果如下：

4、有名管道介绍

有名管道（FIFO）的创建可以使用函数mkfifo()，该函数类似文件中的open()操作，可以指定管道的路径和打开的模式。（用户还可以在终端使用”mknod 管道名 p“来创建有名管道。）

在创建管道成功之后，就可以使用open()、read()和 write()这些函数了。与普通文件的开发设置一样，对于为读操作而打开的管道可在 open()中设置O_RDONLY，对于为写操作而打开的管道可在 open()中设置O_WRONLY，在这里与普通文件不同的是阻塞问题。由于普通文件的读写时不会出现阻塞问题，而在管道的读写中却有阻塞的可能，这里的非阻塞标志可以在open()函数中设定为O_NONBLOCK。下面分别对阻塞打开和非阻塞打开的读写进行讨论。

对于读进程：

（1）若该管道是阻塞打开，且当前FIFO内没有数据，则对读进程而言将一直阻塞到有数据写入。

（2）若该管道是非阻塞打开，则不论FIFO内是否有数据，读进程都会立即执行读操作。即如果FIFO内没有数据，则读函数将立刻返回0。

对于写进程：

（1）若该管道是阻塞打开，则写操作将一直阻塞到数据可以被写入。

（2）若该管道是非阻塞打开而不能写入全部数据，则写操作进行部分写入或者调用失败。

mkfifo()介绍：

int mkfifo(const char* filename,mode_t mode)

filename:要创建的管道

mode:

O_RDONLY:读管道

O_WRONLY:写管道

O_RDWR:读写管道

O_NONBLOCK:非阻塞

O_CREAT:如果该文件不存在，那么就创建一个新的文件，并用第三个参数为其设置权限。

O_EXCL:如果使用O_CREAT时文件存在，那么可返回错误信息。这一参数可测试文件是否存在。

返回值：

成功：0

错误：-1

使用实例：

#include <fcntl.h> 
#include <stdio.h> 
#include <unistd.h> 
#include <stdlib.h> 
#include <time.h> 
#include <errno.h> 
 

#define FIFO1               "in1"
#define FIFO2               "in2"
#define MAX_BUFFER_SIZE     1024               /* 缓冲区大小*/ 
#define IN_FILES              3                  /* 多路复用输入文件数目*/ 
#define TIME_DELAY            60                 /* 超时值秒数 */ 
#define MAX(a, b)             ((a > b)?(a):(b))

int main()
{
    int fds[IN_FILES]; 
     char buf[MAX_BUFFER_SIZE]; 
     int i, res, real_read, maxfd; 
     struct timeval tv; 
     fd_set inset,tmp_inset; 
    fds[0] = 0; 

    /*创建两个有名管道*/
    //access函数可以用来判断某个文件是否存在（访问权限）
    if(access(FIFO1,F_OK)==-1)//FIFO表示有名管道，FIFO1代表in1
    {
        if((mkfifo(FIFO1,0666)<0)  &&  (errno!=EEXIST))//mkfifo创建有名管道，0666代表权限设置，0代表
        //没有执行权限，6代表有读写权限，小于代表创建失败
        {
            printf("cannot create fifo file\n");
            exit(1);
        }
    }
    if(access(FIFO2,F_OK)==-1)
    {
        if((mkfifo(FIFO2,0666)<0)  &&  (errno!=EEXIST))
        {
            printf("cannot create fifo file\n");
            exit(1);
        }
    }

     /*首先以只读非阻塞方式打开两个管道文件*/ 
     if((fds[1] = open (FIFO1, O_RDONLY|O_NONBLOCK)) < 0) 
     { 
          printf("Open in1 error\n"); 
          return 1; 
     } 
     if((fds[2] = open (FIFO2, O_RDONLY|O_NONBLOCK)) < 0) 
     { 
        printf("Open in2 error\n"); 
          return 1; 
     }
     /*取出两个文件描述符中的较大者*/ 
     maxfd = MAX(MAX(fds[0], fds[1]), fds[2]); 
     /*初始化读集合inset，并在读集合中加入相应的描述集*/ 
     FD_ZERO(&inset);  
     for (i = 0; i < IN_FILES; i++) 
     { 
         FD_SET(fds[i], &inset); 
     } 
     FD_SET(0, &inset); 
     tv.tv_sec = TIME_DELAY; 
     tv.tv_usec = 0; 
      /*循环测试该文件描述符是否准备就绪，并调用select 函数对相关文件描述符做对应操作*/ 
     while(FD_ISSET(fds[0],&inset)  
            || FD_ISSET(fds[1],&inset) || FD_ISSET(fds[2], &inset)) 
     {  
          /* 文件描述符集合的备份， 这样可以避免每次进行初始化 */ 
          tmp_inset = inset;  
          res = select(maxfd + 1, &tmp_inset, NULL, NULL, &tv); 
           
          switch(res) 
          { 
          case -1: 
              { 
                   printf("Select error\n"); 
                   return 1; 
              } 
              break; 
                
               case 0: /* Timeout */ 
               { 
                   printf("Time out\n"); 
                   return 1; 
              }           
              break; 
                
               default: 
               { 
                   for (i = 0; i < IN_FILES; i++) 
                   { 
                        if (FD_ISSET(fds[i], &tmp_inset)) 
                        { 
                            memset(buf, 0, MAX_BUFFER_SIZE);
                              real_read = read(fds[i], buf, MAX_BUFFER_SIZE); 
                     
                            if (real_read < 0) 
                            { 
                                 if (errno != EAGAIN) 
                                 { 
                                     return 1; 
                                 } 
                            } 
                             else if (!real_read) 
                             { 
                                 close(fds[i]); 
                                 FD_CLR(fds[i], &inset); 
                            } 
                            else 
                            { 
                                 if (i == 0) 
                                 {/* 主程序终端控制 */ 
                                      if ((buf[0] == 'q') || (buf[0] == 'Q')) 
                                      { 
                                           return 1; 
                                      } 
                                 } 
                                 else 
                                 {/* 显示管道输入字符串 */ 
                                      buf[real_read] = '\0'; 
                                      printf("%s", buf); 
                                 } 
                            } 
                       } /* end of if */ 
                   } /* end of for */ 
              } 
              break;       
 
         } /* end of switch */ 
     } /*end of while */ 
 
     return 0; 
}

流程图如下所示：

学不会！！！！！

关注

18
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
管道通信介绍

管道是Linux中进程间通信的一种方式，它把一个程序的输出直接连接到另一个程序的输入。linux的管道主要包括无名管道和有名管道。（1）无名管道无名管道是linux中管道通信的一种原始方法，它具有如下特点：a、它只能用于具有亲缘关系的进程之间的通信(也就是父子进程或者兄弟进程之间)。b、它是一个半双工的通信模式，具有固定的读端和写端。c、管道也可以看成是一种特殊的文件，对于它的读写也可以使用普通的read()、write()等函数。
复制链接

扫一扫