【Linux】进程间通信2——命名管道

1. 命名管道(FIFO)

1.1. 基本概念

简单，给匿名管道起个名字就变成了命名管道

那么如何给 匿名管道 起名字呢？

• 结合文件系统，给匿名管道这个纯纯的内存文件分配 inode，将文件名与之构建联系，关键点在于不给它分配 Data block，因为它是一个纯纯的内存文件，是不需要将数据刷盘到磁盘中的

可以将命名管道理解为 "挂名" 后的匿名管道，把匿名管道加入文件系统中，但仅仅是挂个名而已，目的就是为了让其他进程也能看到这个文件（文件系统中的文件可以被所有进程看到）

因为没有 Data block，所以命名管道这个特殊文件大小为 0

匿名管道只能用于具有共同祖先的进程（具有亲缘关系的进程）之间的通信，如果要实现两个毫不相关进程之间的通信，可以使用命名管道来做到。

普通文件是很难做到通信的，即便做到通信也无法解决一些安全问题。

命名管道和匿名管道一样，都是内存文件，只不过命名管道在磁盘有一个简单的映像，但这个映像的大小永远为0，因为命名管道和匿名管道都不会将通信数据刷新到磁盘当中。

不同于匿名管道之处在于它提供一个路径名与之关联，以FIFO的文件形式存储于文件系统中。

1. 命名管道是一个文件，因此，即使进程与创建FIFO的进程不存在亲缘关系，只要可以访问该路径，就能够通过FIFO相互通信。
2. 值得注意的是，FIFO(first input first output)总是按照先进先出的原则工作，第一个被写⼊的数据将首先从管道中读出。

匿名管道是在进程中由pipe()系统调用创建的管道文件. 对用户来说其实是不可见的. 也不能被其他毫无干系的进程打开. 只能通过pipe创建、打开

而命名管道则不同, 命名管道对用户来说, 是可见的, 也就是说在进程内是可以指定路径打开的 , 这也是 命名管道可以实现 毫不相干的进程之间通信的原因

1.2.毫不相干的进程之间是怎么通信的

命名管道就是一种特殊类型的文件，两个进程通过命名管道的文件名打开同一个管道文件，此时这两个进程也就看到了同一份资源，进而就可以进行通信了。

虽然命名管道看起来很像文件，但是本质上这个文件也是一个内存文件，只不过在内存上只有一个简单的映像，永远都是 0 ，就只占了一个名字罢了。两个进程只需要通过这个名字在内存中打开文件就好了。

我们来验证一下

我要完成的目的是在用户端 client 输入数据(从屏幕中读取去)，而在客户端 server 接收客户端的数据，然后再从客户端打印出来。

但是这里需要注意的是，我们要想进行通信，那么就必须可以看到同一份资源，所以这里我就将共同的资源放到了头文件里，然后两个程序就可以看到同一份资源了：

comm.h
  1 #pragma once
  2 #include <stdio.h>
  3 #include <unistd.h>
  4 #include <string.h>
  5 #include <sys/types.h>
  6 #include <sys/stat.h>                                                   
  7 #include <fcntl.h>
  8 
  9 #define FILE_NAME "myfifo"

server.c
  1 #include"comm.h"
  2                                                                         
  3 int main()
  4 {
  5   if(mkfifo(FILE_NAME, 0644) < 0){
  6     perror("myfifo");
  7     return 1;
  8   }
  9 
 10   int fd = open(FILE_NAME, O_RDONLY);
 11   if(fd < 0){
 12     perror("open");
 13     return 2;
 14   }
 15 
 16   char msg[128];
 17   while(1){
 18     msg[0] = 0;
 19     ssize_t s = read(fd, msg, sizeof(msg)- 1);
 20     if(s > 0){
 21       msg[s] = 0;
 22       printf("client# %s\n", msg);
 23     }
 24     else if(s == 0){
 25       printf("client quit!\n");
 26       break;
 27     }
 28     else{
 29       printf("read error!\n");
 30       break;                                                             
 31     }
 32   }
 33   close(fd);
 34 
 35   return 0;
 36 }
 

client.c
  1 #include"comm.h"
  2 
  3 int main()
  4 {
  5   int fd = open(FILE_NAME, O_WRONLY);
  6   if(fd < 0){
  7     perror("open");
  8     return 1;                                                           
  9   }                                                  
 10                                                  
 11   char msg[128];  
 12   while(1){                                   
 13     msg[0] = 0;                      
 14     printf("Please Enter# ");
 15     fflush(stdout);                     
 16     ssize_t s = read(0, msg, sizeof(msg));
 17     if(s > 0){
 18       msg[s] = 0;                                                  
 19       write(fd, msg, strlen(msg));                               
 20     }                                                     
 21   }                                   
 22                                                         
 23   close(fd);                                  
 24   return 0;
 25 }                             

我们可以看到这样的效果。

而且我们会发现，这两个进程是没有任何关系的，但是它们两个就可以进行通信。而且除了 server 创建一个管道文件，其它的操作和操作普通文件没有区别。

那么接下来就操作：情况是不是在命名管道开头的那幅图的情况：

首先先把 server 中读取的操作去掉：

然后进行下方操作：

我们可以看到，我已经写了好多消息了，但是我们发现 myfifo 的大小一直都是 0 ，换句话说就是我写的消息已经被写到管道的缓冲区里了，但是 server端 并没有读取，所以写的消息还是在内存里，但是又因为 myfifo 的大小为 0 ，就说明数据并没有刷新到磁盘，也就意味着，双方通信依旧是在内存中通信的，和匿名管道的底层原理是一样的，它们采用的都是文件通信。

所以这下也就更能理解上面的那副图了吧。

1.3.命名管道的工作原理

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

不同点：

1. 匿名管道只能用于具有血缘关系的进程间通信；而命名管道不讲究，谁都可以用
2. 匿名管道直接通过 pipe 函数创建使用；而命名管道需要先通过 mkfifo 函数创建，然后再通过 open 打开使用
3. 出现多条匿名管道时，可能会出现写端 fd 重复继承的情况；而命名管道不会出现这种情况
   在其他方面，匿名管道与命名管道几乎一致

两个都属于管道家族，都是最古老的进程间通信方式，都自带同步与互斥机制，提供的都是流式数据传输

2.创建命名管道

2.1.mkfifo命令

我们可以使用mkfifo命令来创建命名管道

mkfifo 命名管道的名字

成功解锁了一种新的特殊类型文件：p 管道文件

这个管道文件也非常特殊：大小为 0，从侧面说明 管道文件就是一个纯纯的内存级文件，有自己的上限，出现在文件系统中，只是单纯挂个名而已

2.2.mkfifo函数

此外我们还可以通过相关的函数来创建，这个函数也叫mkfifo

​
#include <sys/types.h>
#include <sys/stat.h>

int mkfifo(const char *path,mode_t mode);

path为创建的命名管道的全路径名：
mod为指定了文件的读写权限； 

成功都返回0，失败都返回－1

​

参数 : mkfifo函数的第一个参数是pathname，表示要创建的命名管道文件。

• 若pathname以路径的方式给出，则将命名管道文件创建在pathname路径下。
• 若pathname以文件名的方式给出，则将命名管道文件默认创建在当前路径下。（注意当前路径的含义）

mkfifo函数的第二个参数是mode，表示创建命名管道文件的默认权限。

返回值: 命名管道创建成功，返回0 ; 命名管道创建失败，返回-1。

3.命名管道的使用

命名管道和管道的使用方法法基本是相同的。

只是使用命名管道时，必须先调用open()将其打开。因为命名管道是一个存在于硬盘上的文件，而管道是存在于内存中的特殊文件。

需要注意的是，调用open()打开命名管道的进程可能会被阻塞。

1. 但如果同时用读写方式（ O_RDWR）打开，则一定不会导致阻塞；
2. 如果以只读方式（ O_RDONLY）打开，则调用open()函数的进程将会被阻塞直到有写方打开管道；
3. 同样以写方式（ O_WRONLY）打开也会阻塞直到有读方式打开管道。

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

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

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

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

4.命名管道的四个使用示例

(1)通过命名管道 ，client & server进行通信

①comm.h中包含一些头文件供client 和 server使用

//comm.h
#pragma once
 
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>
 
#define FILE_NAME "myfifo" //让客户端和服务端使用同一个命名管道

②server.c 代码

实现服务端(server)和客户端(client)之间的通信之前，我们需要先让服务端运行起来，我们需要让服务端运行后创建一个命名管道文件，然后再以读的方式打开该命名管道文件，之后服务端就可以从该命名管道当中读取客户端发来的通信信息了。

#include "comm.h"
 
 
int main()
{
  if(mkfifo(FILE_NAME , 0644) < 0){ //创建管道文件
    perror("mkfifo");
  }
 
 int fd = open(FILE_NAME , O_RDONLY); //只读形式打开
 if(fd < 0){
   perror("open error!\n");
   return 2;
 }
 
 char buf[128];
 while(1){
   ssize_t s = read(fd ,buf, sizeof(buf)-1); //开始读数据
   if(s > 0){
      buf[s] = 0;
      printf("client# %s\n" , buf);
   }
   else if(s == 0){
      printf("client quit!\n");
      break;
   }
   else{
      printf("read error!\n");
      break;
   }
 }
 
 close(fd);
  return 0;
}

③client.c 代码

而对于客户端来说，因为服务端运行起来后命名管道文件就已经被创建了，所以客户端只需以写的方式打开该命名管道文件，之后客户端就可以将通信信息写入到命名管道文件当中，进而实现和服务端的通信。

#include "comm.h"
 
 
int main()
{
  int fd = open(FILE_NAME , O_WRONLY); //以写的方式打开文件
  if(fd < 0){
    perror("open error!\n");
    return 1;
  }
 
  char buf[128];
  while(1){
    printf("Please Enter# ");  //提示语句
    fflush(stdout);
    ssize_t s = read(0 , buf , sizeof(buf));  //从键盘中读取数据
   if(s > 0){
     buf[s-1] = 0; //输入时多了一个\n
     write(fd , buf ,strlen(buf)); //把读取到的数据写到管道中
   }
 
  }
 
  return 0;
}

④运行结果

客户端写入的信息进入命名管道当中，服务端再从命名管道当中将信息读取出来打印在服务端的显示器上，该现象说明服务端是能够通过命名管道获取到客户端发来的信息的，换句话说，此时这两个进程之间是能够通信的。

通过ps命令查看这两个进程的信息，可以发现这两个进程确实是两个毫不相关的进程，因为它们的PID和PPID都不相同

⑤client 和 server 谁先退出问题

1. 客户端先退出，服务端将管道当中的数据读完后就再也读不到数据了，那么此时服务端也就会去执行它的其他代码了（在当前代码中是直接退出了）。

2)服务端先退出，客户端写入管道的数据就不会被读取了，也就没有意义了，那么当客户端下一次再向管道写入数据时，就会收到操作系统发来的13号信号(SIGPIPE)，此时客户端就被操作系统强制杀掉了。

⑥通信是在内存当中进行的

client端代码不变 ，server端只是以读的方式打开，但是不读取数据 :

运行程序前后两次查看myfifo管道文件的大小始终为0，说明了双方进程之间的通信依旧是在内存当中进行的，和匿名管道通信是一样的。

(2)通过命名管道，派发计算任务

①两个进程之间的通信，并不是简单的发送字符串而已，服务端是会对客户端发送过来的信息进行某些处理的 ; 这里我们的client端发送计算任务，server端将数据计算出来并打印到显示器上。

②client端的代码没有发生变化，只是server端读取数据时对数据进行了一些处理:

#include "comm.h"
 
 
int main()
{
  if(mkfifo(FILE_NAME , 0644) < 0){ //创建管道文件
    perror("mkfifo");
  }
 
 int fd = open(FILE_NAME , O_RDONLY); //只读形式打开
 if(fd < 0){
   perror("open error!\n");
   return 2;
 }
 
 char buf[128];
 while(1){
   ssize_t s = read(fd ,buf, sizeof(buf)-1); //开始读数据
   if(s > 0){
      buf[s] = 0;
 
     //简单计算
     char *p = buf;
     const char *lable="+-*/%";
     int flag = 0; //记录计算的符号，利用下标 
     while(*p){
         switch(*p){
             case '+':
                 flag = 0;
                 break;
             case '-':
                 flag = 1;
                 break;
             case '*':
                 flag = 2;
                 break;
             case '/':
                 flag = 3;
                 break;
             case '%':
                 flag = 4;
                 break;
         }
         p++;
     }
 
     char *data1 = strtok(buf, "+-*/%"); //通过算数符号将左右两个数字分开
     char *data2 = strtok(NULL, "+-*/%");
     int x = atoi(data1); //将字符转整形计算
     int y = atoi(data2);
     int z = 0;
     switch(flag){
         case 0:
             z = x + y;
             break;
         case 1:
             z = x - y;
             break;
         case 2:
             z = x * y;
             break;
         case 3:
             z = x / y;
             break;
         case 4:
             z = x % y;
             break;
     }
 
     printf("%d %c %d = %d\n", x,lable[flag], y, z);
   }
   else if(s == 0){
      printf("client quit!\n");
      break;
   }
   else{
      printf("read error!\n");
      break;
   }
 }
 
 close(fd);
  return 0;
}

③结果

(3)通过命名管道，进行命令操作

①我们可以通过一个进程来控制另一个进程的行为，比如我们从客户端输入命令到管道当中，再让服务端将管道当中的命令读取出来并执行。简单实现了让服务端执行不带选项的命令，若是想让服务端执行带选项的命令，可以对管道当中获取的命令进行进一步的解析处理。

②client端的代码不变，server端对于输入的数据进行解析，如果有命令则执行:

#include "comm.h"
 
 
int main()
{
  if(mkfifo(FILE_NAME , 0644) < 0){ //创建管道文件
    perror("mkfifo");
  }
 
 int fd = open(FILE_NAME , O_RDONLY); //只读形式打开
 if(fd < 0){
   perror("open error!\n");
   return 2;
 }
 
 char buf[128];
 while(1){
   ssize_t s = read(fd ,buf, sizeof(buf)-1); //开始读数据
   if(s > 0){
      buf[s] = 0;
      printf("client# %s\n" , buf);
 
     //执行命令
      if(fork() == 0){ //child
         execlp(buf , buf ,NULL); //进程替换
         exit(1);
      }
 
      waitpid(-1 , NULL ,0); //进程等待
 
   }
   else if(s == 0){
      printf("client quit!\n");
      break;
   }
   else{
      printf("read error!\n");
      break;
   }
 }
 
 close(fd);
  return 0;
}

(4)通过命名管道，进行文件拷贝

①大致思路是，client端将log.txt 文件通过管道发送给server端，server端读取管道中的数据创建一个本地文件，将数据拷贝到本地文件中，以此来实现文件的拷贝。(本实验是在同一个机器上，且在同一个目录下，所以发送文件的文件名不能和接受文件的文件名重复)

②client端代码 : 以读的方式打开log.txt文件 ， 以写的方式打开管道文件 ，将log.txt文件中的数据写到管道中.

#include "comm.h"
 
 
int main()
{
  int fd = open(FILE_NAME, O_WRONLY); //以写的方式打开命名管道文件
	if (fd < 0){
		perror("open");
		return 1;
	}
 
	int fdin = open("log.txt", O_RDONLY); //以读的方式打开log.txt文件
	if (fdin < 0){
		perror("open");
		return 2;
	}
 
	char buf[128];
	while (1){
		//从log.txt文件当中读取数据
		ssize_t s = read(fdin, buf, sizeof(buf));
		if (s > 0){
			write(fd, buf, s); //将读取到的数据写入到命名管道当中
		}
		else if (s == 0){
			printf("read end of file!\n");
			 break;
		}
		else{
			printf("read error!\n");
			break;
		}
	}
 
	close(fd); //通信完毕，关闭命名管道文件
	close(fdin); //数据读取完毕，关闭log.txt文件
	return 0;
}

③server端代码 : 以读的方式打开管道文件(没有管道文件创建) ， 以写的方式在本地创建一个log-bat.txt文件，并将管道中的数据写到log-bat.txt文件中。

#include "comm.h"
 
 
int main()
{
  if(mkfifo(FILE_NAME , 0644) < 0){ //创建管道文件
    perror("mkfifo");
  }
 
 int fd = open(FILE_NAME , O_RDONLY); //只读形式打开
 if(fd < 0){
   perror("open error!\n");
   return 2;
 }
 
 int fdout = open("log-bat.txt" , O_WRONLY|O_CREAT , 0644);
 if(fdout < 0){
   perror("open error!\n");
   return 3;
 }
 
 char buf[128];
 while(1){
   ssize_t s = read(fd ,buf, sizeof(buf)-1); //开始读数据
   if(s > 0){
    write(fdout , buf , s); //将数据从管道写入文件
   }
   else if(s == 0){
     printf("client quit!\n");
     break;
   }
   else{
     printf("read error!\n");
     break;
   }
 }
 
  close(fd); //通信关闭，关闭管道文件描述符
  close(fdout); //数据写入完毕
  return 0;
}

⑤进一步理解文件拷贝

使用管道在本地进行的文件拷贝，所以看似没什么意义，但我们若是将这里的管道想象成"网络"，将客户端想象成"Windows Xshell"，再将服务端想象成"centos服务器", 那我们此时实现的就是文件上传的功能，若是将方向反过来，那么实现的就是文件下载的功能。

(5). 命名管道和匿名管道的区别

• 匿名管道由pipe函数创建并打开。
• 命名管道由mkfifo函数创建，由open函数打开。
• FIFO（命名管道）与pipe（匿名管道）之间唯一的区别在于它们创建与打开的方式不同，一旦这些工作完成之后，它们具有相同的语义。

5.命令行中的管道理解

(1)使用cat 和 grep 命令 ， 利用 管道 " | " 对信息进行过滤。

(2)管道" | " 是匿名管道还是命名管道 ？

①由于匿名管道只能用于有亲缘关系的进程之间的通信，而命名管道可以用于两个毫不相关的进程之间的通信，因此我们可以先看看命令行当中用管道（"|"）连接起来的各个进程之间是否具有亲缘关系。

②通过管道连接了三个进程，通过ps命令查看这三个进程可以发现，这三个进程的PPID是相同的，也就是说它们是由同一个父进程创建的子进程。

③三个sleep进程的父进程是bash ，三个sleep进程互为兄弟

④结论

若是两个进程之间采用的是命名管道，那么在磁盘上必须有一个对应的命名管道文件名，而实际上我们在使用命令的时候并不存在类似的命名管道文件名，因此命令行上的管道实际上是匿名管道。