Go语言视频零基础入门到精通

admin

命名管道的概述
无名管道，由于没有名字，只能用于亲缘关系的进程间通信（更多详情，请看《无名管道》）。为了克服这个缺点，提出了命名管道（FIFO），也叫有名管道、FIFO 文件。


命名管道（FIFO）不同于无名管道之处在于它提供了一个路径名与之关联，以 FIFO 的文件形式存在于文件系统中，这样，即使与 FIFO 的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过 FIFO 相互通信，因此，通过 FIFO 不相关的进程也能交换数据。



命名管道（FIFO)和无名管道（pipe）有一些特点是相同的，不一样的地方在于:

  1、FIFO 在文件系统中作为一个特殊的文件而存在，但 FIFO 中的内容却存放在内存中。
  2、当使用 FIFO 的进程退出后，FIFO 文件将继续保存在文件系统中以便以后使用。

  3、FIFO 有名字，不相关的进程可以通过打开命名管道进行通信。

命名管道的创建
所需头文件：

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

int mkfifo( const char *pathname, mode_t mode);
功能：

  命名管道的创建。

参数：

  pathname: 普通的路径名，也就是创建后 FIFO 的名字。

  mode: 文件的权限，与打开普通文件的 open() 函数中的 mode 参数相同，相关说明请点此链接。

返回值：

  成功：0
失败：如果文件已经存在，则会出错且返回 -1。

  

示例代码如下：
  

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <sys/stat.h>
5. int main(int argc, char *argv[])
6. {
7.         int ret;
8.        
9.         ret = mkfifo("my_fifo", 0666); // 创建命名管道
10.         if(ret != 0){        // 出错
11.                 perror("mkfifo");
12.         }
13.        
14.         return 0;
15. }

复制代码

运行结果如下：




命名管道的默认操作
后期的操作，把这个命名管道当做普通文件一样进行操作：open()、write()、read()、close()。但是，和无名管道一样，操作命名管道肯定要考虑默认情况下其阻塞特性。


下面验证的是默认情况下的特点，即 open() 的时候没有指定非阻塞标志( O_NONBLOCK )。
1）
open() 以只读方式打开 FIFO 时，要阻塞到某个进程为写而打开此 FIFO
open() 以只写方式打开 FIFO 时，要阻塞到某个进程为读而打开此 FIFO。
简单一句话，只读等着只写，只写等着只读，只有两个都执行到，才会往下执行。


只读端代码如下：
  

1. #include <stdio.h>
2. #include <string.h>
3. #include <unistd.h>
4. #include <sys/types.h>
5. #include <sys/stat.h>
6. #include <fcntl.h>
8. int main(int argc, char *argv[])
9. {
10.         int fd;
11.         int ret;
12.        
13.         ret = mkfifo("my_fifo", 0666);
14.         if(ret != 0)
15.         {
16.                 perror("mkfifo");
17.         }
18.        
19.         printf("before open\n");
20.         fd = open("my_fifo", O_RDONLY);//等着只写
21.         if(fd < 0)
22.         {
23.                 perror("open fifo");
24.         }
25.        
26.         printf("after open\n");
27.        
28.         return 0;
29. }

复制代码

  
只写端代码如下
  

1. #include <stdio.h>
2. #include <string.h>
3. #include <unistd.h>
4. #include <sys/types.h>
5. #include <sys/stat.h>
6. #include <fcntl.h>
8. int main(int argc, char *argv[])
9. {
10.         int fd;
11.         int ret;
12.        
13.         ret = mkfifo("my_fifo", 0666);
14.         if(ret != 0)
15.         {
16.                 perror("mkfifo");
17.         }
18.        
19.         printf("before open\n");
20.         fd = open("my_fifo", O_WRONLY); //等着只读
21.         if(fd < 0)
22.         {
23.                 perror("open fifo");
24.         }
25.        
26.         printf("after open\n");
27.        
28.         return 0;
29. }

复制代码

大家开启两个终端，分别编译以上代码，读端程序和写端程序各自运行，如下图，大家自行验证其特点，因为光看结果图是没有效果，大家需要分析其运行过程是如何变化。




如果大家不想在 open() 的时候阻塞，我们可以以可读可写方式打开 FIFO 文件，这样 open() 函数就不会阻塞。
  

1. // 可读可写方式打开
2. int fd = open("my_fifo", O_RDWR);

复制代码

  
2）假如 FIFO 里没有数据，调用 read() 函数从 FIFO 里读数据时 read() 也会阻塞。这个特点和无名管道是一样的。


写端代码如下：
  

1. #include <stdio.h>
2. #include <string.h>
3. #include <unistd.h>
4. #include <sys/types.h>
5. #include <sys/stat.h>
6. #include <fcntl.h>
8. int main(int argc, char *argv[])
9. {
10.         int fd;
11.         int ret;
12.        
13.         ret = mkfifo("my_fifo", 0666);//创建命名管道
14.         if(ret != 0)
15.         {
16.                 perror("mkfifo");
17.         }
18.        
19.         printf("before open\n");
20.         fd = open("my_fifo", O_WRONLY); //等着只读
21.         if(fd < 0)
22.         {
23.                 perror("open fifo");
24.         }
25.         printf("after open\n");
26.        
27.         printf("before write\n");
28.         // 5s后才往命名管道写数据，没数据前，读端read()阻塞
29.         sleep(5);
30.         char send[100] = "Hello Mike";
31.         write(fd, send, strlen(send));
32.         printf("write to my_fifo buf=%s\n", send);
33.        
34.         return 0;
35. }

复制代码

读端代码如下：
  
  

1. #include <stdio.h>
2. #include <string.h>
3. #include <unistd.h>
4. #include <sys/types.h>
5. #include <sys/stat.h>
6. #include <fcntl.h>
8. int main(int argc, char *argv[])
9. {
10.         int fd;
11.         int ret;
12.        
13.         ret = mkfifo("my_fifo", 0666); //创建命名管道
14.         if(ret != 0)
15.         {
16.                 perror("mkfifo");
17.         }
18.        
19.         printf("before open\n");
20.         fd = open("my_fifo", O_RDONLY);//等着只写
21.         if(fd < 0)
22.         {
23.                 perror("open fifo");
24.         }
25.         printf("after open\n");
26.        
27.         printf("before read\n");
28.         char recv[100] = {0};
29.        
30.         //读数据，命名管道没数据时会阻塞，有数据时就取出来
31.         read(fd, recv, sizeof(recv));
32.         printf("read from my_fifo buf=[%s]\n", recv);
33.        
34.         return 0;
35. }

复制代码

请根据下图自行编译运行验证：
  




3）通信过程中若写进程先退出了，就算命名管道里没有数据，调用 read() 函数从 FIFO 里读数据时不阻塞；若写进程又重新运行，则调用 read() 函数从 FIFO 里读数据时又恢复阻塞。


写端代码如下：
  

1. #include <stdio.h>
2. #include <string.h>
3. #include <unistd.h>
4. #include <sys/types.h>
5. #include <sys/stat.h>
6. #include <fcntl.h>
8. int main(int argc, char *argv[])
9. {
10.         int fd;
11.         int ret;
12.        
13.         ret = mkfifo("my_fifo", 0666); // 创建命名管道
14.         if(ret != 0)
15.         {
16.                 perror("mkfifo");
17.         }
18.        
19.         fd = open("my_fifo", O_WRONLY); // 等着只读
20.         if(fd < 0)
21.         {
22.                 perror("open fifo");
23.         }
24.        
25.         char send[100] = "Hello Mike";
26.         write(fd, send, strlen(send));        //写数据
27.         printf("write to my_fifo buf=%s\n",send);
28.        
29.         while(1); // 阻塞，保证读写进程保持着通信过程
30.        
31.         return 0;
32. }

复制代码

读端代码如下：

  

1. #include <stdio.h>
2. #include <string.h>
3. #include <unistd.h>
4. #include <sys/types.h>
5. #include <sys/stat.h>
6. #include <fcntl.h>
8. int main(int argc, char *argv[])
9. {
10.         int fd;
11.         int ret;
12.        
13.         ret = mkfifo("my_fifo", 0666);// 创建命名管道
14.         if(ret != 0)
15.         {
16.                 perror("mkfifo");
17.         }
18.        
19.         fd = open("my_fifo", O_RDONLY);// 等着只写
20.         if(fd < 0)
21.         {
22.                 perror("open fifo");
23.         }
24.        
25.         while(1)
26.         {
27.                 char recv[100] = {0};
28.                 read(fd, recv, sizeof(recv)); // 读数据
29.                 printf("read from my_fifo buf=[%s]\n",recv);
30.                 sleep(1);
31.         }
32.        
33.         return 0;
34. }

复制代码

请根据下图自行编译运行验证：




5）通信过程中，读进程退出后，写进程向命名管道内写数据时，写进程也会（收到 SIGPIPE 信号）退出。

6）调用 write() 函数向 FIFO 里写数据，当缓冲区已满时 write() 也会阻塞。



5）和 6）这两个特点和无名管道是一样的，这里不再验证，详情请看《无名管道》。


命名管道非阻塞标志操作
命名管道可以以非阻塞标志（O_NONBLOCK）方式打开：
  

1. fd = open("my_fifo", O_WRONLY|O_NONBLOCK);
2. fd = open("my_fifo", O_RDONLY|O_NONBLOCK);

复制代码

  


非阻塞标志（O_NONBLOCK）打开的命名管道有以下特点：
1、先以只读方式打开，如果没有进程已经为写而打开一个 FIFO, 只读 open() 成功，并且 open() 不阻塞。

2、先以只写方式打开，如果没有进程已经为读而打开一个 FIFO，只写 open() 将出错返回 -1。

3、read()、write() 读写命名管道中读数据时不阻塞。



请根据以下代码自行编译运行验证。


写端代码如下：
  

1. #include <stdio.h>
2. #include <string.h>
3. #include <unistd.h>
4. #include <sys/types.h>
5. #include <sys/stat.h>
6. #include <fcntl.h>
8. int main(int argc, char *argv[])
9. {
10.         int fd;
11.         int ret;
12.        
13.         ret = mkfifo("my_fifo", 0666); // 创建命名管道
14.         if(ret != 0)
15.         {
16.                 perror("mkfifo");
17.         }
18.        
19.         // 只写并指定非阻塞方式打开
20.         fd = open("my_fifo", O_WRONLY|O_NONBLOCK);
21.         if(fd<0)
22.         {
23.                 perror("open fifo");
24.         }
25.        
26.         char send[100] = "Hello Mike";
27.         write(fd, send, strlen(send));
28.         printf("write to my_fifo buf=%s\n",send);
29.         while(1);
30.        
31.         return 0;
32. }

复制代码

读端代码如下：
  
  

1. #include <stdio.h>
2. #include <string.h>
3. #include <unistd.h>
4. #include <sys/types.h>
5. #include <sys/stat.h>
6. #include <fcntl.h>
8. int main(int argc, char *argv[])
9. {
10.         int fd;
11.         int ret;
12.        
13.         ret = mkfifo("my_fifo", 0666); // 创建命名管道
14.         if(ret != 0)
15.         {
16.                 perror("mkfifo");
17.         }
18.        
19.         // 只读并指定非阻塞方式打开
20.         fd = open("my_fifo", O_RDONLY|O_NONBLOCK);
21.         if(fd < 0)
22.         {
23.                 perror("open fifo");
24.         }
25.        
26.         while(1)
27.         {
28.                 char recv[100] = {0};
30.                 read(fd, recv, sizeof(recv));
31.                 printf("read from my_fifo buf=[%s]\n",recv);
32.                 sleep(1);
33.         }
34.        
35.         return 0;
36. }

复制代码

本教程示例代码下载请点此处。