Linux进程间通信——使用命名管道

简介: 在前一篇文章——Linux进程间通信——使用匿名管道中,我们看到了如何使用匿名管道来在进程之间传递数据,同时也看到了这个方式的一个缺陷,就是这些进程都由一个共同的祖先进程启动,这给我们在不相关的的进程之间交换数据带来了不方便。
在前一篇文章—— Linux进程间通信——使用匿名管道中,我们看到了如何使用匿名管道来在进程之间传递数据,同时也看到了这个方式的一个缺陷,就是这些进程都由一个共同的祖先进程启动,这给我们在不相关的的进程之间交换数据带来了不方便。这里将会介绍进程的另一种通信方式——命名管道,来解决不相关进程间的通信问题。
 
一、什么是命名管道
命名管道也被称为FIFO文件,它是一种特殊类型的文件,它在文件系统中以文件名的形式存在,但是它的行为却和之前所讲的没有名字的管道(匿名管道)类似。
 
由于Linux中所有的事物都可被视为文件,所以对命名管道的使用也就变得与文件操作非常的统一,也使它的使用非常方便,同时我们也可以像平常的文件名一样在命令中使用。
 
二、创建命名管道
我们可以使用两下函数之一来创建一个命名管道,他们的原型如下:
 
[cpp]  view plain copy print ?
 
  1. #include <sys/types.h>  
  2. #include <sys/stat.h>  
  3. int mkfifo(const char *filename, mode_t mode);  
  4. int mknod(const char *filename, mode_t mode | S_IFIFO, (dev_t)0);  
这两个函数都能创建一个FIFO文件,注意是创建一个真实存在于文件系统中的文件,filename指定了文件名,而mode则指定了文件的读写权限。
 
mknod是比较老的函数,而使用mkfifo函数更加简单和规范,所以建议在可能的情况下,尽量使用mkfifo而不是mknod。
 
三、访问命名管道
 
1、打开FIFO文件
与打开其他文件一样,FIFO文件也可以使用open调用来打开。注意,mkfifo函数只是创建一个FIFO文件,要使用命名管道还是将其打开。
 
但是有两点要注意,1、就是程序不能以O_RDWR模式打开FIFO文件进行读写操作,而其行为也未明确定义,因为如一个管道以读/写方式打开,进程就会读回自己的输出,同时我们通常使用FIFO只是为了单向的数据传递。2、就是传递给open调用的是FIFO的路径名,而不是正常的文件。
 
打开FIFO文件通常有四种方式,
 
[cpp]  view plain copy print ?
 
  1. open(const char *path, O_RDONLY);//1  
  2. open(const char *path, O_RDONLY | O_NONBLOCK);//2  
  3. open(const char *path, O_WRONLY);//3  
  4. open(const char *path, O_WRONLY | O_NONBLOCK);//4  
在open函数的调用的第二个参数中,你看到一个陌生的选项O_NONBLOCK,选项O_NONBLOCK表示非阻塞,加上这个选项后,表示open调用是非阻塞的,如果没有这个选项,则表示open调用是阻塞的。
 
open调用的阻塞是什么一回事呢?很简单,对于以只读方式(O_RDONLY)打开的FIFO文件,如果open调用是阻塞的(即第二个参数为O_RDONLY),除非有一个进程以写方式打开同一个FIFO,否则它不会返回;如果open调用是非阻塞的的(即第二个参数为O_RDONLY | O_NONBLOCK),则即使没有其他进程以写方式打开同一个FIFO文件,open调用将成功并立即返回。
 
对于以只写方式(O_WRONLY)打开的FIFO文件,如果open调用是阻塞的(即第二个参数为O_WRONLY),open调用将被阻塞,直到有一个进程以只读方式打开同一个FIFO文件为止;如果open调用是非阻塞的(即第二个参数为O_WRONLY | O_NONBLOCK),open总会立即返回,但如果没有其他进程以只读方式打开同一个FIFO文件,open调用将返回-1,并且FIFO也不会被打开。
 
四、使用FIFO实现进程间的通信
说了这么多,下面就用一个例子程序来说明一下,两个进程如何通过FIFO实现通信吧。这里有两个源文件,一个fifowrite.c,它在需要时创建管道,然后向管道写入数据,数据由文件Data.txt提供,大小为10M,内容全是字符‘0’。另一个源文件为fiforead.c,它从FIFO中读取数据,并把读到的数据保存到另一个文件DataFormFIFO.txt中。为了让程序更加简洁,忽略了有些函数调用是否成功的检查。
 
fifowrite.c的源代码如下:
 
[cpp]  view plain copy print ?
 
  1. #include <unistd.h>  
  2. #include <stdlib.h>  
  3. #include <fcntl.h>  
  4. #include <limits.h>  
  5. #include <sys/types.h>  
  6. #include <sys/stat.h>  
  7. #include <stdio.h>  
  8. #include <string.h>  
  9.   
  10. int main()  
  11. {  
  12.     const char *fifo_name = "/tmp/my_fifo";  
  13.     int pipe_fd = -1;  
  14.     int data_fd = -1;  
  15.     int res = 0;  
  16.     const int open_mode = O_WRONLY;  
  17.     int bytes_sent = 0;  
  18.     char buffer[PIPE_BUF + 1];  
  19.   
  20.     if(access(fifo_name, F_OK) == -1)  
  21.     {  
  22.         //管道文件不存在  
  23.         //创建命名管道  
  24.         res = mkfifo(fifo_name, 0777);  
  25.         if(res != 0)  
  26.         {  
  27.             fprintf(stderr, "Could not create fifo %s\n", fifo_name);  
  28.             exit(EXIT_FAILURE);  
  29.         }  
  30.     }  
  31.   
  32.     printf("Process %d opening FIFO O_WRONLY\n", getpid());  
  33.     //以只写阻塞方式打开FIFO文件,以只读方式打开数据文件  
  34.     pipe_fd = open(fifo_name, open_mode);  
  35.     data_fd = open("Data.txt", O_RDONLY);  
  36.     printf("Process %d result %d\n", getpid(), pipe_fd);  
  37.   
  38.     if(pipe_fd != -1)  
  39.     {  
  40.         int bytes_read = 0;  
  41.         //向数据文件读取数据  
  42.         bytes_read = read(data_fd, buffer, PIPE_BUF);  
  43.         buffer[bytes_read] = '\0';  
  44.         while(bytes_read > 0)  
  45.         {  
  46.             //向FIFO文件写数据  
  47.             res = write(pipe_fd, buffer, bytes_read);  
  48.             if(res == -1)  
  49.             {  
  50.                 fprintf(stderr, "Write error on pipe\n");  
  51.                 exit(EXIT_FAILURE);  
  52.             }  
  53.             //累加写的字节数,并继续读取数据  
  54.             bytes_sent += res;  
  55.             bytes_read = read(data_fd, buffer, PIPE_BUF);  
  56.             buffer[bytes_read] = '\0';  
  57.         }  
  58.         close(pipe_fd);  
  59.         close(data_fd);  
  60.     }  
  61.     else  
  62.         exit(EXIT_FAILURE);  
  63.   
  64.     printf("Process %d finished\n", getpid());  
  65.     exit(EXIT_SUCCESS);  
  66. }  
源文件fiforead.c的代码如下:
 
[cpp]  view plain copy print ?
 
  1. #include <unistd.h>  
  2. #include <stdlib.h>  
  3. #include <stdio.h>  
  4. #include <fcntl.h>  
  5. #include <sys/types.h>  
  6. #include <sys/stat.h>  
  7. #include <limits.h>  
  8. #include <string.h>  
  9.   
  10. int main()  
  11. {  
  12.     const char *fifo_name = "/tmp/my_fifo";  
  13.     int pipe_fd = -1;  
  14.     int data_fd = -1;  
  15.     int res = 0;  
  16.     int open_mode = O_RDONLY;  
  17.     char buffer[PIPE_BUF + 1];  
  18.     int bytes_read = 0;  
  19.     int bytes_write = 0;  
  20.     //清空缓冲数组  
  21.     memset(buffer, '\0', sizeof(buffer));  
  22.   
  23.     printf("Process %d opening FIFO O_RDONLY\n", getpid());  
  24.     //以只读阻塞方式打开管道文件,注意与fifowrite.c文件中的FIFO同名  
  25.     pipe_fd = open(fifo_name, open_mode);  
  26.     //以只写方式创建保存数据的文件  
  27.     data_fd = open("DataFormFIFO.txt", O_WRONLY|O_CREAT, 0644);  
  28.     printf("Process %d result %d\n",getpid(), pipe_fd);  
  29.   
  30.     if(pipe_fd != -1)  
  31.     {  
  32.         do  
  33.         {  
  34.             //读取FIFO中的数据,并把它保存在文件DataFormFIFO.txt文件中  
  35.             res = read(pipe_fd, buffer, PIPE_BUF);  
  36.             bytes_write = write(data_fd, buffer, res);  
  37.             bytes_read += res;  
  38.         }while(res > 0);  
  39.         close(pipe_fd);  
  40.         close(data_fd);  
  41.     }  
  42.     else  
  43.         exit(EXIT_FAILURE);  
  44.   
  45.     printf("Process %d finished, %d bytes read\n", getpid(), bytes_read);  
  46.     exit(EXIT_SUCCESS);  
  47. }  
 
运行结果如下:
 
分析:两个程序都使用阻塞模式的FIFO,为了让大家更清楚地看清楚阻塞究竟是怎么一回事,首先我们运行fifowrite.exe,并把它放到后台去运行。这时调用jobs命令,可以看到它确实在后台运行着,过了5秒后,再调用jobs命令,可以看到进程fifowrite.exe还没有结束,它还在继续运行。因为fifowrite.exe进程的open调用是阻塞的,在fiforead.exe还没有运行时,也就没有其他的进程以读方式打开同一个FIFO,所以它就一直在等待,open被阻塞,没有返回。然后,当我们进程fiforead.exe运行时(为了查看性能,在time命令中运行),fifowrite.exe中的open调用返回,进程开始继续工作,然后结束进程。而fiforead.exe的open调用虽然也是阻塞模式,但是fifowrite.exe早已运行,即早有另一个进程以写方式打开同一个FIFO,所以open调用立即返回。
 
从time中的输出来看,管道的传递效率是非常高的,因为fiforead.exe既要读取数据,还要写数据到文件DataFormFIFO.txt中,10M的数据只用了0.1秒多一点。
 
此外,如果此时,你在shell中输入如下命令,ls -l /tmp/my_fifo,可以看到如下结果:
 
 
证明FIFO文件确实是存在于文件系统中的文件,文件属性的第一个字符为‘p',表示该文件是一个管道。
 
五、命名管道的安全问题
前面的例子是两个进程之间的通信问题,也就是说,一个进程向FIFO文件写数据,而另一个进程则在FIFO文件中读取数据。试想这样一个问题,只使用一个FIFO文件,如果有多个进程同时向同一个FIFO文件写数据,而只有一个读FIFO进程在同一个FIFO文件中读取数据时,会发生怎么样的情况呢,会发生数据块的相互交错是很正常的?而且个人认为多个不同进程向一个FIFO读进程发送数据是很普通的情况。
 
为了解决这一问题,就是让写操作的原子化。怎样才能使写操作原子化呢?答案很简单,系统规定:在一个以O_WRONLY(即阻塞方式)打开的FIFO中, 如果写入的数据长度小于等待PIPE_BUF,那么或者写入全部字节,或者一个字节都不写入。如果所有的写请求都是发往一个阻塞的FIFO的,并且每个写记请求的数据长度小于等于PIPE_BUF字节,系统就可以确保数据决不会交错在一起。
 
六、命名管道与匿名管道的对比
使用匿名管道,则通信的进程之间需要一个父子关系,通信的两个进程一定是由一个共同的祖先进程启动。但是匿名管道没有上面说到的数据交叉的问题。
 
与使用匿名管道相比,我们可以看到fifowrite.exe和fiforead.exe这两个进程是没有什么必然的联系的,如果硬要说他们具有某种联系,就只能说是它们都访问同一个FIFO文件。它解决了之前在匿名管道中出现的通信的两个进程一定是由一个共同的祖先进程启动的问题。但是为了数据的安全,我们很多时候要采用阻塞的FIFO,让写操作变成原子操作。
目录
打赏
0
0
0
0
93
分享
相关文章
从零开始掌握进程间通信:管道、信号、消息队列、共享内存大揭秘
本文详细介绍了进程间通信(IPC)的六种主要方式:管道、信号、消息队列、共享内存、信号量和套接字。每种方式都有其特点和适用场景,如管道适用于父子进程间的通信,消息队列能传递结构化数据,共享内存提供高速数据交换,信号量用于同步控制,套接字支持跨网络通信。通过对比和分析,帮助读者理解并选择合适的IPC机制,以提高系统性能和可靠性。
301 14
Linux:进程间通信(共享内存详细讲解以及小项目使用和相关指令、消息队列、信号量)
通过上述讲解和代码示例,您可以理解和实现Linux系统中的进程间通信机制,包括共享内存、消息队列和信号量。这些机制在实际开发中非常重要,能够提高系统的并发处理能力和数据通信效率。希望本文能为您的学习和开发提供实用的指导和帮助。
207 20
进程间通信方式-----管道通信
【10月更文挑战第29天】管道通信是一种重要的进程间通信机制,它为进程间的数据传输和同步提供了一种简单有效的方法。通过合理地使用管道通信,可以实现不同进程之间的协作,提高系统的整体性能和效率。
Linux c/c++之IPC进程间通信
这篇文章详细介绍了Linux下C/C++进程间通信(IPC)的三种主要技术:共享内存、消息队列和信号量,包括它们的编程模型、API函数原型、优势与缺点,并通过示例代码展示了它们的创建、使用和管理方法。
102 0
Linux c/c++之IPC进程间通信
|
5月前
|
Linux c/c++进程间通信(1)
这篇文章介绍了Linux下C/C++进程间通信的几种方式,包括普通文件、文件映射虚拟内存、管道通信(FIFO),并提供了示例代码和标准输入输出设备的应用。
63 0
Linux c/c++进程间通信(1)
C语言 多进程编程(二)管道
本文详细介绍了Linux下的进程间通信(IPC),重点讨论了管道通信机制。首先,文章概述了进程间通信的基本概念及重要性,并列举了几种常见的IPC方式。接着深入探讨了管道通信,包括无名管道(匿名管道)和有名管道(命名管道)。无名管道主要用于父子进程间的单向通信,有名管道则可用于任意进程间的通信。文中提供了丰富的示例代码,展示了如何使用`pipe()`和`mkfifo()`函数创建管道,并通过实例演示了如何利用管道进行进程间的消息传递。此外,还分析了管道的特点、优缺点以及如何通过`errno`判断管道是否存在,帮助读者更好地理解和应用管道通信技术。
已解决:连接SqlServer出现 provider: Shared Memory Provider, error: 0 - 管道的另一端上无任何进程【C#连接SqlServer踩坑记录】
本文介绍了解决连接SqlServer时出现“provider: Shared Memory Provider, error: 0 - 管道的另一端上无任何进程”错误的步骤,包括更改服务器验证模式、修改sa用户设置、启用TCP/IP协议,以及检查数据库连接语句中的实例名是否正确。此外,还解释了实例名mssqlserver和sqlserver之间的区别,包括它们在默认设置、功能和用途上的差异。
|
22天前
|
Linux 进程前台后台切换与作业控制
进程前台/后台切换及作业控制简介: 在 Shell 中,启动的程序默认为前台进程,会占用终端直到执行完毕。例如,执行 `./shella.sh` 时,终端会被占用。为避免不便,可将命令放到后台运行,如 `./shella.sh &`,此时终端命令行立即返回,可继续输入其他命令。 常用作业控制命令: - `fg %1`:将后台作业切换到前台。 - `Ctrl + Z`:暂停前台作业并放到后台。 - `bg %1`:让暂停的后台作业继续执行。 - `kill %1`:终止后台作业。 优先级调整:
37 5
掌握taskset:优化你的Linux进程,提升系统性能
在多核处理器成为现代计算标准的今天,运维人员和性能调优人员面临着如何有效利用这些处理能力的挑战。优化进程运行的位置不仅可以提高性能,还能更好地管理和分配系统资源。 其中,taskset命令是一个强大的工具,它允许管理员将进程绑定到特定的CPU核心,减少上下文切换的开销,从而提升整体效率。
掌握taskset:优化你的Linux进程,提升系统性能