进程间通信 --- 命名管道 有名管道存在与内存中，无名管道存在与文件系统中 换种角度看问题

最新推荐文章于 2024-02-04 13:17:10 发布
最新推荐文章于 2024-02-04 13:17:10 发布
阅读量1k 收藏 4
点赞数 3
分类专栏： Linux系统编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alpha_love/article/details/62238213
版权

1）open() 以只读方式打开 FIFO 时，要阻塞到某个进程为写而打开此 FIFO
      open() 以只写方式打开 FIFO 时，要阻塞到某个进程为读而打开此 FIFO。
   简单一句话，只读等着只写，只写等着只读，只有两个都执行到，才会往下执行。

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

3）通信过程中，若写进程先退出了，就算命名管道里没有数据，

         调用 read() 函数从 FIFO 里读数据时也不阻塞；
         若写进程又重新运行，则调用 read() 函数从 FIFO 里读数据时又恢复阻塞。
5）通信过程中，读进程退出后，写进程向命名管道内写数据时，写进程也会（收到 SIGPIPE 信号）退出。
6）调用 write() 函数向 FIFO 里写数据，当缓冲区已满时 write() 也会阻塞。

5）和 6）这两个特点和无名管道是一样的，这里不再验证   


命名管道可以以非阻塞标志（O_NONBLOCK）方式打开：
fd = open("my_fifo", O_WRONLY  |   O_NONBLOCK);  
fd = open("my_fifo", O_RDONLY   |   O_NONBLOCK);  
非阻塞标志（O_NONBLOCK）打开的命名管道有以下特点：
1、先以只读方式打开，如果没有进程已经为写而打开一个 FIFO, 只读 open() 成功，并且 open() 不阻塞。
2、先以只写方式打开，如果没有进程已经为读而打开一个 FIFO，只写 open() 将出错返回 -1。
3、read()、write() 读写命名管道中读数据时不阻塞。

1. 命名管道的概述

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

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

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

1、FIFO 在文件系统中作为一个特殊的文件而存在，但 FIFO 中的内容却存放在内存中。

2、当使用 FIFO 的进程退出后，FIFO 文件将继续保存在文件系统中以便以后使用。

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

2. 命名管道的创建

所需头文件：

#include <sys/types.h>

#include <sys/stat.h>

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

功能：

命名管道的创建。

参数：

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

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

返回值：

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

示例代码如下：

#include <stdio.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
  
int main(int argc, char *argv[])  
{  
    int ret;  
      
    ret = mkfifo("my_fifo", 0666); // 创建命名管道  
    if(ret != 0){   // 出错  
        perror("mkfifo");  
    }  
      
    return 0;  
}  

运行结果如下：

 

3. 命名管道的默认操作

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

下面验证的是默认情况下的特点，即 open() 的时候没有指定非阻塞标志( O_NONBLOCK )。

1）open() 以只读方式打开 FIFO 时，要阻塞到某个进程为写而打开此 FIFO
      open() 以只写方式打开 FIFO 时，要阻塞到某个进程为读而打开此 FIFO。

简单一句话，只读等着只写，只写等着只读，只有两个都执行到，才会往下执行。

只读端代码如下：

#include <stdio.h>  
#include <string.h>  
#include <unistd.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
#include <fcntl.h>  
int main(int argc, char *argv[])  
{  
		int fd;  
		int ret;  
		
		ret = mkfifo("my_fifo", 0666);  
		if(ret != 0)  
		{  
		perror("mkfifo");  
		}  
		
		printf("before open\n");  
		fd = open("my_fifo", O_RDONLY);//等着只写  
		if(fd < 0)  
		{  
		perror("open fifo");  
		}  
		
		printf("after open\n");  
		
		return 0;  
}

只写端代码如下

#include <stdio.h>  
#include <string.h>  
#include <unistd.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
#include <fcntl.h>  
int main(int argc, char *argv[])  
{  
		int fd;  
		int ret;     
		ret = mkfifo("my_fifo", 0666);  
		if(ret != 0)  
		{  
		perror("mkfifo");  
		}  
		
		printf("before open\n");  
		fd = open("my_fifo", O_WRONLY); //等着只读  
		if(fd < 0)  
		{  
		perror("open fifo");  
		}  
		
		printf("after open\n");  
		
		return 0;  
}

大家开启两个终端，分别编译以上代码，读端程序和写端程序各自运行，如下图，

大家自行验证其特点，因为光看结果图是没有效果，大家需要分析其运行过程是如何变化。

在各自运行之前会相互阻塞，相互等待

 

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

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

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

写端代码如下：

#include <stdio.h>  
#include <string.h>  
#include <unistd.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
#include <fcntl.h>  
  
int main(int argc, char *argv[])  
{  
    int fd;  
    int ret;  
      
    ret = mkfifo("my_fifo", 0666);//创建命名管道  
    if(ret != 0)  
    {  
        perror("mkfifo");  
    }  
      
    printf("before open\n");  
    fd = open("my_fifo", O_WRONLY); //等着只读  
    if(fd < 0)  
    {  
        perror("open fifo");  
    }  
    printf("after open\n");  
      
    printf("before write\n");  
    // 5s后才往命名管道写数据，没数据前，读端read()阻塞  
    sleep(5);  
    char send[100] = "Hello Mike";  
    write(fd, send, strlen(send));  
    printf("write to my_fifo buf=%s\n", send);  
      
    return 0;  
}

读端代码如下：

#include <stdio.h>  
#include <string.h>  
#include <unistd.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
#include <fcntl.h>  
  
int main(int argc, char *argv[])  
{  
    int fd;  
    int ret;  
      
    ret = mkfifo("my_fifo", 0666); //创建命名管道  
    if(ret != 0)  
    {  
        perror("mkfifo");  
    }  
      
    printf("before open\n");  
    fd = open("my_fifo", O_RDONLY);//等着只写  
    if(fd < 0)  
    {  
        perror("open fifo");  
    }  
    printf("after open\n");  
      
    printf("before read\n");  
    char recv[100] = {0};  
      
    //读数据，命名管道没数据时会阻塞，有数据时就取出来  
    read(fd, recv, sizeof(recv));   
    printf("read from my_fifo buf=[%s]\n", recv);  
      
    return 0;  
}

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

 

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

     若写进程又重新运行，则调用 read() 函数从 FIFO 里读数据时又恢复阻塞。

写端代码如下：

#include <stdio.h>  
#include <string.h>  
#include <unistd.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
#include <fcntl.h>  
  
int main(int argc, char *argv[])  
{  
    int fd;  
    int ret;  
      
    ret = mkfifo("my_fifo", 0666); // 创建命名管道  
    if(ret != 0)  
    {  
        perror("mkfifo");  
    }  
      
    fd = open("my_fifo", O_WRONLY); // 等着只读  
    if(fd < 0)  
    {  
        perror("open fifo");  
    }  
      
    char send[100] = "Hello Mike";  
    write(fd, send, strlen(send));  //写数据  
    printf("write to my_fifo buf=%s\n",send);  
      
    while(1); // 阻塞，保证读写进程保持着通信过程  
      
    return 0;  
}

​​​​​​读端代码如下：

#include <stdio.h>  
#include <string.h>  
#include <unistd.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
#include <fcntl.h>  
  
int main(int argc, char *argv[])  
{  
    int fd;  
    int ret;  
      
    ret = mkfifo("my_fifo", 0666);// 创建命名管道  
    if(ret != 0)  
    {  
        perror("mkfifo");  
    }  
      
    fd = open("my_fifo", O_RDONLY);// 等着只写  
    if(fd < 0)  
    {  
        perror("open fifo");  
    }  
      
    while(1)  
    {  
        char recv[100] = {0};  
        read(fd, recv, sizeof(recv)); // 读数据  
        printf("read from my_fifo buf=[%s]\n",recv);  
        sleep(1);  
    }  
      
    return 0;  
}

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

5）通信过程中，读进程退出后，写进程向命名管道内写数据时，写进程也会（收到 SIGPIPE 信号）退出。
6）调用 write() 函数向 FIFO 里写数据，当缓冲区已满时 write() 也会阻塞。

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

4. 命名管道非阻塞标志操作

命名管道可以以非阻塞标志（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() 读写命名管道中读数据时不阻塞。

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

写端代码如下：

#include <stdio.h>  
#include <string.h>  
#include <unistd.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
#include <fcntl.h>  
  
int main(int argc, char *argv[])  
{  
    int fd;  
    int ret;  
      
    ret = mkfifo("my_fifo", 0666); // 创建命名管道  
    if(ret != 0)  
    {  
        perror("mkfifo");  
    }  
      
    // 只写并指定非阻塞方式打开  
    fd = open("my_fifo", O_WRONLY|O_NONBLOCK);  
    if(fd<0)  
    {  
        perror("open fifo");  
    }  
      
    char send[100] = "Hello Mike";  
    write(fd, send, strlen(send));  
    printf("write to my_fifo buf=%s\n",send);  
    while(1);  
      
    return 0;  
}

​​​​​​读端代码如下：

#include <stdio.h>  
#include <string.h>  
#include <unistd.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
#include <fcntl.h>  
  
int main(int argc, char *argv[])  
{  
    int fd;  
    int ret;  
      
    ret = mkfifo("my_fifo", 0666); // 创建命名管道  
    if(ret != 0)  
    {  
        perror("mkfifo");  
    }  
      
    // 只读并指定非阻塞方式打开  
    fd = open("my_fifo", O_RDONLY|O_NONBLOCK);  
    if(fd < 0)  
    {  
        perror("open fifo");  
    }  
      
    while(1)  
    {  
        char recv[100] = {0};  
  
        read(fd, recv, sizeof(recv));  
        printf("read from my_fifo buf=[%s]\n",recv);  
        sleep(1);  
    }  
      
    return 0;  
}

换种角度看待这个管道问题：

1. 读还是写操作管道           2.管道内有无数据       3.读端先退出还是写端先退出   

alpha_2017
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Linux编程基础：管道与消息队列
PermanentFiend_的博客
05-21 705
一，管道 管道其实质是由内核管理的一个缓冲区 形象地认为管道的两端连接着两个进程： 一个进程进行信息输出，将数据写入管道； 另一个进程进行信息输入，从管道中读取信息。 管道分为： 匿名管道：只能用于有亲缘关系的进程间通信，进程退出后管道会被销毁。 命名管道：命名管道与进程的联系较弱，相当于一个读写内存的接口，进程退出后，命名管道依然存在。 匿名管道 匿名管道的使用流程如下： ①在进程中创建匿名管道，pipe函数； ②关闭进程中不使用的管道端口，close函数； ③在待通信的进程中分别对管道的读、写
进程通信之管道
qq_36534818的博客
05-19 197
在谈管道之前我们先了解一下什么是进程间通信。         每个进程各自有不同的用户地址空间，任何一个进程的全局变量在另一个进程中都看不到，所以进程间要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷贝到内核，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC,InterProcess Communication）。如下图所示
Linux进程间通信--管道（pipe）与命名管道（FIFO）及其阻塞状态
m0_52870614的博客
01-30 1220
我们知道进程间通信方式有：管道，FIFO，消息队列，共享存储，信号量，套接字，STREAMS这几种，今天我们来谈一谈pipe和FIFO。 首先我们先来看一下定义： 管道pipe：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。 命名管道FIFO：有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。 我们先来看一下管道： 一般管道有这样的应用场景，父进程给一个只写信号到管道，子进程进行读取，或者子写父读。在管道等待输入的过程我们
如何做出一个简易的管道fifo进行聊天
weixin_44997096的博客
09-18 251
首先我们先熟悉管道的概念 管道 1、有名管道的性质 2、有名管道的创建 3、有名管道读写实现 有名管道的性质 项目2 项目3
【命名管道】命名管道（FIFO）与进程通信
crr411422的博客
06-28 585
命名管道（FIFO）为我们提供了一个在不同进程间进行数据传递的简单而有效的途径。了解如何正确使用FIFO，避免常见的问题，比如权限设定和缓冲区管理。虽然有其复杂性，但是只要掌握了这些要点，我们就能够用好FIFO，为进程间的通信带来便利。
进程间通信-2，有名无名管道，信号量，消息队列，共享内存。
08-27
在计算机科学领域，进程间通信（IPC，Inter-Process Communication）是操作系统中多个进程之间进行数据交换和协调操作的关键机制。本主题将深入探讨四种主要的IPC方式：有名无名管道、信号量、消息队列和共享内存。...
实验五-进程间通信实验(二).doc
11-17
在本实验中，我们将主要关注进程间通信方式，包括无名管道和有名管道。 一、无名管道 无名管道是一种-half duplex communication way，允许两个进程之间进行数据交换。无名管道是一种特殊的文件描述符，它可以在父...
Linux管道详解-管道通信、无名管道、有名管道、具体应用示例
11-25
无名管道（PIPE）是一种亲缘进程间的通信方法2.1 无名管道的通信原理无名管道存在于kernel中，A，B必须具有亲缘关系进程。同一时刻，只能有一个写端或一个读端。父子进程间，只要是fork()出来的，就会完美复制父...
linux编程及应用-任继平08第08章进程间通信－管道和信号.ppt
09-28
【进程间通信】是操作系统中进程协作和交互的重要机制，主要分为无名管道(Pipe)和有名管道(FIFO)两种类型。本章讲解了这两类管道的原理和使用方法，以及信号(Signal)的处理机制。 **无名管道(Pipe)**是一种半双工的...
进程间通信－管道和信号.ppt
09-06
**有名管道（FIFO）**与无名管道类似，但提供了进程间通信的更通用方式。FIFO在文件系统中有一个路径名，任何进程都可以通过打开这个路径来读写数据，因此可以实现不具有亲缘关系的进程间通信。创建FIFO使用`mkfifo...
Linux系统编程——进程间通信：命名管道（FIFO）
热门推荐
秋叶原 && Mike || 麦克
06-02 7万+
无名管道，由于没有名字，只能用于亲缘关系的进程间通信（更多详情，请看《无名管道》）。为了克服这个缺点，提出了命名管道（FIFO），也叫有名管道、FIFO 文件。 命名管道（FIFO）不同于无名管道之处在于它提供了一个路径名与之关联，以 FIFO 的文件形式存在于文件系统中，这样，即使与 FIFO 的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过 FIFO 相互通信，因此，通过 FIFO 不相关的进程也能交换数据。
命名管道的基本用法
最新发布
憧憬，思考，奋斗，飞翔
02-04 1093
命名管道的基本用法
python进程间通信——命名管道（Named Pipe、FIFO）
Dontla的博客
01-21 2809
命名管道与普通管道类似，都是基于字节流进行通信的，但不同的是命名管道有路径名与之关联，并且其生命周期超过了引发创建它的进程。这使得不相关的进程可以通过命名管道进行通信。
进程间通信之命名管道
k5426244的博客
07-17 702
管道应用的一个限制就是（具有亲缘关系）的进程间通信，这种通信可以用来实现。如果我们想，可以使用FIFO文件来做这项工作，它经常被称为。1.什么是命名管道？命名管道（named pipe）也称为FIFO，它是一种文件类型，创建一个FIFO文件类似于创建一个普通文件。FIFO解决了只有具有亲缘关系的进程间才能通信的问题。并且命名管道是一种特殊类型的文件。2.匿名管道与命名管道的区别？
进程间通信IPC——命名管道
Zhang_1218的博客
11-29 930
命名管道1、基本概念2、创建1）命令行2）函数3、示例 1、基本概念 命名管道是一种特殊的文件类型，其存在于磁盘上，但是大小永远是0。 不同于匿名管道的是： 可在同一台计算机的不同进程之间或在跨越网络的不同计算机的不同进程之间实现通信 支持可靠的、单向或双向的数据通信 命名管道只是让两个无关的进程之间建立起联系，一旦关系建立起来，与命名管道的文件不再有关 命名管道FIFO(first input first output)总是遵循先进先出的原则，即第一个进来的数据会第一个被读走 命名管道可以一个读端，多个
C语言命名管道open阻塞的原因与解决方法
阿猪米德的小本本
05-20 3320
C语言命名管道open阻塞的原因与解决方法 open()的第一个参数是文件路径，第二个参数是打开的文件的读写方式（只写，只读，读写）与堵塞/非堵塞设置。 由于open函数的第二个参数如果加上O_NONBLOCK非堵塞，则会在执行open的时候立即返回，若出错则会设置errno。本话题旨在解决不设置O_NONBLOCK非堵塞时出现的堵塞情况分析。 查阅博客资料，发现有关读写打开的堵塞在此不再赘述，请...
Linux有名管道（FIFO）的阻塞和非阻塞读写
heguangsui123的博客
04-02 2077
有名管道的读写有阻塞和非阻塞两种，可以在open()时指定，下面我们对各种情况进行一些讨论。 //写进程 #include <sys/types.h> #include <sys/stat.h> #include <errno.h> #include <fcntl.h> #include <string.h> #include <stdio.h> #define FIFO_NAME "/tmp/myfifo" main() {
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值