Linux环境进程间通信(二):有名管道(FIFO)

转载 2012年03月28日 11:46:04

转自:https://www.ibm.com/developerworks/cn/linux/l-ipc/part1/

1 有名管道相关的关键概念

管道应用的一个重大限制是它没有名字,因此,只能用于具有亲缘关系的进程间通信,在有名管道(named pipe或FIFO)提出后,该限制得到了克服。

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

值得注意的是,FIFO严格遵循先进先出(first in first out),对管道及FIFO的读总是从开始处返回数据,对它们的写则把数据添加到末尾。

它们不支持诸如lseek()等文件定位操作。

2 有名管道的创建

使用mkfifo()函数来创建

包含头文件:

#include <sys/types.h>

#include <sys/stat.h>

函数原型:

int mkfifo(const char * pathname, mode_t mode)

参数:

pathname是一个普通的路径名,也就是创建后FIFO的名字;

mode指出FIFO文件的操作权限,与打开普通文件的open()函数中的mode 参数相同。 

常用的mode:

O_CREAT:如果文件不存在,则创建之;

O_EXCL:确保此次调用会创建文件;

如果mkfifo的第一个参数是一个已经存在的路径名时,会返回EEXIST错误,所以一般典型的调用代码首先会检查是否返回该错误,如果确实返回该错误,那么只要调用打开FIFO的函数就可以了。一般文件的I/O函数都可以用于FIFO,如close、read、write等等。

返回值:

创建成功,则返回0;

失败则返回-1;

错误类型:

 EEXIST 路径名已存在(最常用的判断)

ENAMETOOLONG/ ENOENT/ENOSPC/ ENOTDIR/ EROFS

3 有名管道的打开规则

有名管道比管道多了一个打开操作:open(),以供读取或者写入

包含头文件:

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

函数原型:

int open(const char *pathname, int flags);

int open(const char *pathname, int flags, mode_t mode);

参数:

1> pathname:指出文件名

2> flags:至少包含一下一种访问权限:O_RDONLY ( read only ),  O_WRONLY( write only ),  or  O_RDWR( read/write ).

falgs需要与一些文件状态标识进行“ 或 ”操作

FIFO常用的文件状态标识:O_NONBLOCK or O_NDELAY

即表示非阻塞(如果不设置,则默认为阻塞),含义看下文解释。

3> mode:一般取0即可;

返回值:

如果打开成功,则返回一个新的文件描述符;

如果打开失败,则返回-1,并设置响应的errno

FIFO常用到的错误:

ENXIO:当设置flags为O_NONBLOCK  |  O_WRONLY时,文件为FIFO,并且进程没有文件打开以供写;

FIFO的打开规则:

如果当前打开操作是为读而打开FIFO时,若已经有相应进程为写而打开该FIFO,则当前打开操作将成功返回;否则,可能阻塞直到有相应进程为写而打开该FIFO(当前打开操作设置了阻塞标志);或者,成功返回(当前打开操作没有设置阻塞标志)。

如果当前打开操作是为写而打开FIFO时,如果已经有相应进程为读而打开该FIFO,则当前打开操作将成功返回;否则,可能阻塞直到有相应进程为读而打开该FIFO(当前打开操作设置了阻塞标志);或者,返回ENXIO错误(当前打开操作没有设置阻塞标志)。

对FIFO打开规则的验证(主要验证写打开对读打开的依赖性)

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

#define FIFO_SERVER "/tmp/fifoserver"

int handle_client(char*);

int main()
{
    int r_rd;
    int w_fd;
    pid_t pid;

    //创建FIFO,并检查是否已有同名的FIFO文件
    if((mkfifo(FIFO_SERVER,O_CREAT|O_EXCL)<0)&&(errno!=EEXIST))
    {
        printf("cannot create fifoserver\n");
    }
    //创建成功
    handle_client(FIFO_SERVER);
}

int handle_client(char* arg)
{
    int ret;
    ret=w_open(arg);
    switch(ret)
    {
    case 0:
        { 
            printf("open %s error\n",arg);
            printf("no process has the fifo open for reading\n");
            return -1;
        }
    case -1:
        {
            printf("something wrong with open the fifo except for ENXIO");
            return -1;
        }
    case 1:
        {
            printf("open server ok\n");
            return 1;
        }
    default:
        {
            printf("w_no_r return ----\n");
            return 0;
        }
    }

    unlink(FIFO_SERVER);
}

//返回0,表示打开失败,因为没有文件
//返回-1,表示打开失败,但是因为别的原因
//返回1,表示打开成功
int w_open(char*arg)
{
    if(open(arg,O_WRONLY|O_NONBLOCK,0)==-1)
    { 
        if(errno==ENXIO)
        {
            return 0;
        }
        else
        {
            return -1;
        }
    }

    return 1;
}
4 有名管道的读写规则

从FIFO中读取数据:

约定:

如果一个进程为了从FIFO中读取数据而阻塞打开FIFO(open()时不设置O_NONBLOCK ),那么称该进程内的读操作为设置了阻塞标志的读操作

如果有进程写打开FIFO,且当前FIFO内没有数据

        1> 则对于设置了阻塞标志的读操作来说,将一直阻塞

        2> 对于没有设置阻塞标志读操作来说则返回-1,当前errno值为EAGAIN,提醒以后再试。

对于设置了阻塞标志的读操作说,造成阻塞的原因有两种:

        1> 当前FIFO内有数据,但有其它进程在读这些数据;

        2> FIFO内没有数据。

解阻塞的原因则是FIFO中有新的数据写入,不论信写入数据量的大小,也不论读操作请求多少数据量。

读打开的阻塞标志只对本进程第一个读操作施加作用,如果本进程内有多个读操作序列,则在第一个读操作被唤醒并完成读操作后,其它将要执行的读操作将不再阻塞,即使在执行读操作时,FIFO中没有数据也一样(此时,读操作返回0)。

如果没有进程写打开FIFO,则设置了阻塞标志的读操作会阻塞。

注:如果FIFO中有数据,则设置了阻塞标志的读操作不会因为FIFO中的字节数小于请求读的字节数而阻塞,此时,读操作会返回FIFO中现有的数据量。

使用read()方法从FIFO中读取数据

包含头文件:

#include <unistd.h>

函数原型:

ssize_t read(int fd, void *buf, size_t count);

功能:

从文件描述符fd中读取count字节到buf中;

参数:

如果count==0,则函数返回0;如果count大于buf的size,结果不确定??

返回值:

如果读取成功,则返回读取的字节数;

(当申请的字节数多余fd中可读的字节数时,返回的值小于count)

如果读取失败,则返回-1;

FIFO中可能出现的错误:

EAGAIN or EWOULDBLOCK:The  file  descriptor  fd refers to a socket and has been marked nonblocking   (O_NONBLOCK),   and   the   read   would    block.

向FIFO中写入数据:

约定:如果一个进程为了向FIFO中写入数据而阻塞打开FIFO(open()时不设置O_NONBLOCK ),那么称该进程内的写操作为设置了阻塞标志的写操作

对于设置了阻塞标志的写操作:

        1> 当要写入的数据量不大于PIPE_BUF时,linux将保证写入的原子性。

              如果此时管道空闲缓冲区不足以容纳要写入的字节数,则进入睡眠,直到当缓冲区中能够容纳要写入的字节数时,才开始进行一次性写操作。

        2> 当要写入的数据量大于PIPE_BUF时,linux将不再保证写入的原子性

              FIFO缓冲区一有空闲区域,写进程就会试图向管道写入数据,写操作在写完所有请求写的数据后返回。

对于没有设置阻塞标志的写操作:

        1> 当要写入的数据量大于PIPE_BUF时,linux将不再保证写入的原子性。在写满所有FIFO空闲缓冲区后,写操作返回。(不保证所有数据都能写入)

        2> 当要写入的数据量不大于PIPE_BUF时,linux将保证写入的原子性。

              如果当前FIFO空闲缓冲区能够容纳请求写入的字节数,写完后成功返回;

              如果当前FIFO空闲缓冲区不能够容纳请求写入的字节数,则返回EAGAIN错误,提醒以后再写;

要注意几种不同情况下的区别!

使用write()方法向FIFO写入数据;

包含头文件:

#include <unistd.h>

函数原型:

ssize_t write(int fd, const void *buf, size_t count);

返回值:

如果成功,则返回写入的字节数;

如果失败,返回-1,并设置相应的errno;

可能出现的错误:

EAGAIN or EWOULDBLOCK:The  file  descriptor  fd refers to a socket and has been marked nonblocking   (O_NONBLOCK),   and   the   write   would   block.

对FIFO读写规则的验证:

下面提供了两个对FIFO的读写程序,适当调节程序中的很少地方或者程序的命令行参数就可以对各种FIFO读写规则进行验证。

程序1:写FIFO的程序

#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

#include "BYHFileOperation.h"
 
#define FIFO_SERVER "/home/stuy1001593/fifoserver"

void printMkfifoErrorInfo(int err);

int main()
{
    char w_buf[4*1024*2]={0};
    int real_wnum;

    //创建FIFO,并检查路径名是否存在
    int nRet=mkfifo(FIFO_SERVER,O_CREAT|O_EXCL);
    if(nRet<0)
    {
        int tempErrno=errno;
        printMkfifoErrorInfo(tempErrno);

        if(errno==EEXIST)
        {
            printf("文件%s已存在\n", FIFO_SERVER);
        }
        else
        {
            exit(-1);
        }
    }

    //设置非阻塞标志的只写操作
    //int open_flag=O_WRONLY|O_NONBLOCK;
    int open_flag=O_WRONLY;
    int fd=BYHFileOperation::Open(FIFO_SERVER, open_flag);

    if(fd==-1)
    {
        if(errno==ENXIO)
        {
            printf("进程没有文件打开,以供写入\n"); 
        }

        exit(-1);
    }

    //写入小于PIPE_BUFF的数据
    real_wnum=write(fd, w_buf, 2048);
    if(real_wnum==-1)
    {
        if(errno==EAGAIN)
        {
            printf("写入到FIFO中时发生错误,FIFO空闲缓存区没有足够的空间,稍后再试\n");
        }

        exit(-1);
    }
    else 
    {
        printf("向FIFO空闲缓存中写入了%dByte\n",real_wnum);
    }

    //写入大于PIPE_BUFF的数据
    real_wnum=write(fd, w_buf, 5000);
    //5000用于测试写入字节大于4096时的非原子性
    //real_wnum=write(fd,w_buf,4096);
    //4096用于测试写入字节不大于4096时的原子性
    if(real_wnum==-1)
    {
        if(errno==EAGAIN)
        {
            printf("写入到FIFO中时发生错误,FIFO空闲缓存区没有足够的空间,稍后再试\n");
        }

        exit(-1);
    }
    else 
    {
        printf("向FIFO空闲缓存中写入了%dByte\n",real_wnum);
    }
}
程序2:与程序1一起测试写FIFO的规则,第一个命令行参数是请求从FIFO读出的字节数
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

#define FIFO_SERVER "/tmp/fifoserver"

int main()
{
    char r_buf[4096*2]={0};
    //FIFO文件描述符
    int fd;
    int r_size=1024;
    int ret_size;

    //以非阻塞方式打开FIFO Server(FIFO发送者)
    fd=open(FIFO_SERVER,O_RDONLY|O_NONBLOCK,0);
    //以阻塞方式打开FIFO
    //fd=open(FIFO_SERVER,O_RDONLY,0);

    if(fd==-1)
    {
        printf("打开FIFO文件%s失败\n", FIFO_SERVER);
        exit(0); 
    }

    while(true)
    {
        //从FIFO中读取到r_buf中
        ret_size=read(fd, r_buf, r_size);
        
        //读取失败
        if(ret_size==-1)
        {
            if(errno==EAGAIN)
            {
                printf("FIFO缓存中没有数据可读,请稍后再试\n");
                sleep(1);
            }
        }

        printf("从FIFO缓存中读取%dBytes\n",ret_size);
        sleep(1);
    }
    pause();
    //删除FIFO文件
    unlink(FIFO_SERVER);
}
程序应用说明:

把读程序编译成两个不同版本:

1>阻塞读版本

2>非阻塞读版本nbr

把写程序编译成两个四个版本:

1> 非阻塞且请求写的字节数大于PIPE_BUF版本:nbwg

2> 非阻塞且请求写的字节数不大于PIPE_BUF版本:版本nbw

3> 阻塞且请求写的字节数大于PIPE_BUF版本:bwg

4> 阻塞且请求写的字节数不大于PIPE_BUF版本:版本bw

小结:

FIFO可以说是管道的推广,克服了管道无名字的限制,使得无亲缘关系的进程同样可以采用先进先出的通信机制进行通信。

管道和FIFO的数据是字节流,应用程序之间必须事先确定特定的传输"协议",采用传播具有特定意义的消息。

要灵活应用管道及FIFO,理解它们的读写规则是关键。


【Linux】进程间通信-命名管道FIFO

命名管道概述 如果我们要在不相关的进程间交换数据,那么使用FIFO文件将会十分方便。 FIFO文件通常也称为命名管道(named pipe)。命名管道是一种特殊类型的文件,它在文件系统中以文件...
  • xiajun07061225
  • xiajun07061225
  • 2013年01月06日 15:41
  • 14810

进程间通信-管道(PIPE)和有名管道(FIFO)

前面我们学习了一下进程,我们知道多,进程间的地址空间相对独立。进程与进程间不能像线程间通过全局变量通信。 如果想进程间通信,就需要其他机制。          常用的进程间通信方式有这...
  • w616589292
  • w616589292
  • 2016年03月22日 18:52
  • 2176

【Linux进程间通信】 - 命名管道FIFO

在前面一篇文章中【Linux进程间通信】 - 匿名管道中,我们介绍了Linux/Unix系统中最古老的一种进程间通信方式 – 匿名管道。此外,我们也讲解了匿名管道的几个局限性,特别是匿名管道只能用...
  • Xiejingfa
  • Xiejingfa
  • 2016年03月08日 16:55
  • 1591

嵌入式 Linux环境进程间通信(二):有名管道(FIFO)

1 有名管道相关的关键概念 管道应用的一个重大限制是它没有名字,因此,只能用于具有亲缘关系的进程间通信,在有名管道(named pipe或FIFO)提出后,该限制得到了克服。 FIFO不同于管道之...
  • skdkjxy
  • skdkjxy
  • 2014年08月29日 17:22
  • 442

Linux环境进程间通信之有名管道(FIFO)的注意事项

1. FIFO文件是受内核保护的,所以程序在执行的时候需要Root权限,否则会提示错误:EACCES 2. 程序执行时,需要创建一个FIFO文件,结束之后应该予以删除,避免造成垃圾文件 3. 除了...
  • xiaobai1593
  • xiaobai1593
  • 2012年04月04日 09:56
  • 1110

linux进程间通信-有名管道(FIFO)

转自: http://www.cnblogs.com/fangshenghui/p/4039805.html 有名管道(FIFO) 命名管道也被称为FIFO文件,是一种特殊的文件。由于linux所...
  • u012256258
  • u012256258
  • 2017年06月08日 16:41
  • 147

Linux--进程间通信(管道及有名管道FIFO)

一. 管道:    1.只能用于具有亲缘关系的进程之间的通信      2.半双工通信模式    3.一种特殊的文件,是一种只存在于内核中的读写函数   管道基于文件描述符,管道建立时,有两...
  • zhangliang_571
  • zhangliang_571
  • 2014年02月20日 19:28
  • 783

Linux--进程间通信(管道及有名管道FIFO)

http://www.cnblogs.com/forstudy/archive/2012/03/22/2412415.html 一. 管道:    1.只能用于具有亲缘关系的进程之间的通信  ...
  • chenyijun
  • chenyijun
  • 2016年07月11日 13:43
  • 253

Linux--进程间通信(管道及有名管道FIFO)

一. 管道:    1.只能用于具有亲缘关系的进程之间的通信      2.半双工通信模式    3.一种特殊的文件,是一种只存在于内核中的读写函数   管道基于文件描述...
  • shan614667793
  • shan614667793
  • 2016年03月09日 16:27
  • 487

【七】 进程间通信——(FIFO)有名管道

【七】  进程间通信——(FIFO)有名管道 我们向管道中写入数据时,linux将不保证写入的原子性,管道缓冲区一有空闲区域,写进程就会试图相关到中写入数据。如果杜金城不读走管道缓冲区的数据...
  • zplove003
  • zplove003
  • 2011年11月15日 20:39
  • 344
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Linux环境进程间通信(二):有名管道(FIFO)
举报原因:
原因补充:

(最多只允许输入30个字)