标签：进程间通信 管道通信 命名管道 linux管道 windows管道
POSIX标准中的FIFO又名有名管道或命名管道。我们知道前面讲述的POSIX标准中管道是没有名称的，所以它的最大劣势是只能用于具有亲缘关系的进程间的通信。FIFO最大的特性就是每个FIFO都有一个路径名与之相关联，从而允许无亲缘关系的任意两个进程间通过FIFO进行通信。
所以，FIFO的两个特性：
**和管道一样，FIFO仅提供半双工的数据通信，即只支持单向的数据流。
**和管道不同的是，FIFO可以支持任意两个进程间的通信。
<span style="font-family:Arial;font-size:12px;">#include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> int mknod(const char *pathname, mode_t mode, dev_t dev);</span>使用方法： mknod 管道名称 p
<span style="font-family:Arial;font-size:12px;">#include<sys/types.h> #include<sys/stat.h> //成功则返回0，失败返回-1 int mkfifo(const char * pathname,mode_t mode);</span>使用方法：mkfifo -m 权限 管道名称
如果mkfifo的第一个参数是一个已经存在的路径名时，会返回EEXIST错误，所以一般典型的调用代码首先会检查是否返回该错误，如果确实返回该错误，那么只要调用打开FIFO的函数就可以了。一般文件的I/O函数都可以用于FIFO，如close、read、write等等。
mkfifo函数默认指定O_CREAT | O_EXECL方式创建FIFO，如果创建成功，直接返回0。如果FIFO已经存在，则创建失败，会返回-1并且errno置为EEXIST。对于其他错误，则置响应的errno值；
当创建一个FIFO后，它必须以只读方式打开或者只写方式打开，所以可以用open函数，当然也可以使用标准的文件I/O打开函数，例如fopen来打开。由于FIFO是半双工的，所以不能够同时打开来读和写。
其实一般的文件I/O函数，如read，write，close，unlink都可用于FIFO。对于管道和FIFO的write操作总是会向末尾添加数据，而对他们的read则总是会从开头数据，所以不能对管道和FIFO中间的数据进行操作，因此对管道和FIFO使用lseek函数，是错误的，会返回ESPIPE错误。
mkfifo的一般使用方式是：通过mkfifo创建FIFO，然后调用open，以读或者写的方式之一打开FIFO，然后进行数据通信。
下面是FIFO的一个简单的测试代码：
<span style="font-family:Arial;font-size:12px;">#include <iostream>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
using namespace std;
#define FIFO_PATH "/root/fifo"
int main()
{
if (mkfifo(FIFO_PATH, 0666) < 0 && errno != EEXIST)
{
cout<<"create fifo failed."<<endl;
return -1;
}
if (fork() == 0)
{
int readfd = open(FIFO_PATH, O_RDONLY);
cout<<"child open fifo success."<<endl;
char buf[256];
read(readfd, buf, sizeof(buf));
cout<<"receive message from pipe: "<<buf<<endl;
close(readfd);
exit(0);
}
sleep(3);
int writefd = open(FIFO_PATH, O_WRONLY);
cout<<"parent open fifo success."<<endl;
char *temp = "hello world";
write(writefd, temp, strlen(temp) + 1);
close(writefd);
}</span>输出：由上面的运行结果可以看到，子进程以读方式open的操作会阻塞到父进程以写方式open；关于这一点以及read和write的操作会在后面管道和FIFO的属性部分进行介绍；
POSIX标准不仅规定了对mkfifo IPC的支持，还包括了对mkfifo shell命令的支持，所以符合POSIX标准的UNIX中都含有mkfifo命令来创建有名管道。
[root@MiWiFi-R1CM csdnblog]# mkfifo fifotest这里在第二行最后加上‘&’使进程转到后台运行，是因为FIFO以只写方式打开需要阻塞到FIFO以只读方式打开为止，所以必须要作为后台程序运行，否则进程会阻塞在前端，无法再进行相关输入。
mknod系统调用会产生由参数path所指定的文件，生成文件类型和访问权限由参数mode决定。
在很多unix的版本中有一个C库函数mkfifo，与mknod不同的是多数情况下mkfifo不要求用户有超级用户的权限。
利用命令创建命名管道p1.
#mkfifo -m 0644 p1
#mknod p2 p
#ll
<span style="font-family:Arial;font-size:12px;">#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
main()
{
if(mkfifo("p1",0644) < 0)
{
perror("mkfifo");
exit(-1);
}
return;
}</span>
有名管道比管道多了一个打开操作：open。
由于在POSIX标准中，管道和FIFO都是通过文件描述符来进行操作的，默认的情况下，对他们的操作都是阻塞的，当然也可以通过设置来使对他们的操作变成非阻塞的。我们都知道可以有两种方式来设置一个文件描述符为O_NONBLOCK非阻塞的：
--调用open时，指定O_NONBLOCK标志。例如：
int fd = open(FILE_NAME, O_RDONLY | O_NONBLOCK);
--通过fcntl文件描述符控制操作函数，对一个已经打开的描述符启用O_NONBLOCK标志。其中对于管道必须使用这种方式。示例如下：
int flag;
flag = fcntl(fd, F_GETFL, 0);
flag |= O_NONBLOCK;
fcntl(fd, F_SETFL, flag);
下图主要说明了对管道和FIFO的各种操作在阻塞和非阻塞状态下的不同，这张图对对于理解和使用管道和FIFO是非常重要的。
从上图我们看到关于管道和FIFO的读出和写入的若干规则，主要需要注意的有以下几点：
· 以只读方式open FIFO时，如果FIFO还没有以只写方式open，那么在阻塞模式下，该操作会阻塞到FIFO以只写方式open为止。
· 以只写方式open FIFO时，如果FIFO还没有以只读方式open，那么在阻塞模式下，该操作会阻塞到FIFO以只读方式open为止。
· 从空管道或空FIFO中read，如果管道和FIFO已打开来写，在阻塞模式下，那么该操作会阻塞到管道或FIFO有数据为止，或管道或FIFO不再以写方式打开。如果管道和FIFO没有打开来写，那么该操作会返回0；
· 向管道或FIFO中write，如果管道或FIFO没有打开来读，那么内核会产生SIGPIPE信号，默认情况下，该信号会终止该进程。
另外对于管道和FIFO还需要说明的若干规则如下：
· 如果请求write的数据的字节数小于等于PIPE_BUF（POSIX关于管道和FIFO大小的限制值），那么write操作可以保证是原子的，如果大于PIPE_BUF，那么就不能保证了。
那么由此可知write的原子性是由写入数据的字节数是否小于等于PIPE_BUF决定的，和是不是O_NONBLOCK没有关系。下面是在阻塞和非阻塞情况下，write不同大小的数据的操作结果：
在阻塞的情况下：
· 如果write的字节数小于等于PIPE_BUF，那么write会阻塞到写入所有数据，并且 写入操作是原子的。
· 如果write的字节数大于PIPE_BUF，那么write会阻塞到写入所有数据，但写入操作不是原子的，即write会根据当前缓冲区剩余的大小，写入相应的字节数，然后等待下一次有空余的缓冲区，这中间可能会有其他进程进行write操作。
在非阻塞的情况下：
· 如果write的字节数小于等于PIPE_BUF，且管道或FIFO有足以存放要写入数据大小的空间，那么就写入所有数据；
· 如果write的字节数小于等于PIPE_BUF，且管道或FIFO没有足够存放要写入数据大小的空间，那么就会立即返回EAGAIN错误。
· 如果write的字节数大于PIPE_BUF，且管道或FIFO有至少1B的空间，那么就内核就会写入相应的字节数，然后返回已写入的字节数；
· 如果write的字节数大于PIPE_BUF，且管道或FIFO无任何的空间，那么就会立即返回EAGAIN错误。
对FIFO打开规则的验证（主要验证写打开对读打开的依赖性）
<span style="font-family:Arial;font-size:12px;">#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 argc, char** argv)
{
int r_rd;
int w_fd;
pid_t pid;
if ((mkfifo(FIFO_SERVER, O_CREAT | O_EXCL) < 0) && (errno != EEXIST))
printf("cannot create fifoserver\n");
handle_client(FIFO_SERVER);
return 0;
}
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);
}
int w_open(char*arg)
//0 open error for no reading
//-1 open error for other reasons
//1 open ok
{
if (open(arg, O_WRONLY | O_NONBLOCK, 0) == -1)
{
if (errno == ENXIO)
{
return 0;
}
else
return -1;
}
return 1;
}</span>输出：通过open打开，默认是阻塞方式打开，如果open指定O_NONBLOCK则以非阻塞打开。
O_NONBLOCK和O_NDELAY所产生的结果都是使I/O变成非搁置模式(non-blocking)，在读取不到数据或是写入缓冲区已满会马上return，而不会搁置程序动作，直到有数据或写入完成。
它们的差别在于设立O_NDELAY会使I/O函式马上回传0，但是又衍生出一个问题，因为读取到档案结尾时所回传的也是0，这样无法得知是哪种情况；因此，O_NONBLOCK就产生出来，它在读取不到数据时会回传-1，并且设置errno为EAGAIN。
不过需要注意的是，在GNU C中O_NDELAY只是为了与BSD的程序兼容，实际上是使用O_NONBLOCK作为宏定义，而且O_NONBLOCK除了在ioctl中使用，还可以在open时设定。
<span style="font-family:Arial;font-size:12px;">#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
main()
{
int fd;
if((fd = open("p1",O_RRONLY,0)) < 0)//只读打开管道
// if((fd = open("p1",O_WRONLY,0)) < 0)//只写打开管道
{
perror("open");
exit(-1);
}
printf("open fifo p1 for write success!\n");
close(fd);
}</span>
从FIFO中读取数据：
约定：如果一个进程为了从FIFO中读取数据而阻塞打开FIFO，那么称该进程内的读操作为设置了阻塞标志的读操作。
·如果有进程写打开FIFO，且当前FIFO内没有数据，则对于设置了阻塞标志的读操作来说，将一直阻塞。对于没有设置阻塞标志读操作来说则返回-1，当前errno值为EAGAIN，提醒以后再试。
·对于设置了阻塞标志的读操作说，造成阻塞的原因有两种：当前FIFO内有数据，但有其它进程在读这些数据；另外就是FIFO内没有数据。解阻塞的原因则是FIFO中有新的数据写入，不论信写入数据量的大小，也不论读操作请求多少数据量。
·读打开的阻塞标志只对本进程第一个读操作施加作用，如果本进程内有多个读操作序列，则在第一个读操作被唤醒并完成读操作后，其它将要执行的读操作将不再阻塞，即使在执行读操作时，FIFO中没有数据也一样（此时，读操作返回0）。
·如果没有进程写打开FIFO，则设置了阻塞标志的读操作会阻塞。
注：如果FIFO中有数据，则设置了阻塞标志的读操作不会因为FIFO中的字节数小于请求读的字节数而阻塞，此时，读操作会返回FIFO中现有的数据量。
向FIFO中写入数据：
约定：如果一个进程为了向FIFO中写入数据而阻塞打开FIFO，那么称该进程内的写操作为设置了阻塞标志的写操作。
对于设置了阻塞标志的写操作：
·当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。如果此时管道空闲缓冲区不足以容纳要写入的字节数，则进入睡眠，直到当缓冲区中能够容纳要写入的字节数时，才开始进行一次性写操作。
·当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。FIFO缓冲区一有空闲区域，写进程就会试图向管道写入数据，写操作在写完所有请求写的数据后返回。
对于没有设置阻塞标志的写操作：
·当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。在写满所有FIFO空闲缓冲区后，写操作返回。
·当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。如果当前FIFO空闲缓冲区能够容纳请求写入的字节数，写完后成功返回；如果当前FIFO空闲缓冲区不能够容纳请求写入的字节数，则返回EAGAIN错误，提醒以后再写；
对FIFO读写规则的验证：
下面提供了两个对FIFO的读写程序，适当调节程序中的很少地方或者程序的命令行参数就可以对各种FIFO读写规则进行验证。
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#define FIFO_SERVER "/tmp/fifoserver"
int main(int argc, char** argv)
//参数为即将写入的字节数
{
int fd;
char w_buf[4096 * 2];
int real_wnum;
memset(w_buf, 0, 4096 * 2);
if ((mkfifo(FIFO_SERVER, O_CREAT | O_EXCL)<0) && (errno != EEXIST))
printf("cannot create fifoserver\n");
if (fd == -1)
{
if (errno == ENXIO)
printf("open error; no reading process\n");
}
fd = open(FIFO_SERVER, O_WRONLY | O_NONBLOCK, 0);
//设置非阻塞标志
//fd=open(FIFO_SERVER,O_WRONLY,0);
//设置阻塞标志
real_wnum = write(fd, w_buf, 2048);
if (real_wnum == -1)
{
if (errno == EAGAIN)
printf("write to fifo error; try later\n");
}
else
{
printf("real write num is %d\n", real_wnum);
}
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("try later\n");
}
return 0;
}没有任何东西输出：
[root@MiWiFi-R1CM csdnblog]# ./a.out
// 下面的程序是与上面的程序一起测试写FIFO的规则，第一个命令行参数是请求从FIFO读出的字节数
<span style="font-family:Arial;font-size:12px;">#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#define FIFO_SERVER "/tmp/fifoserver"
main(int argc,char** argv)
{
char r_buf[4096*2];
int fd;
int r_size;
int ret_size;
r_size=atoi(argv[1]);
printf("requred real read bytes %d\n",r_size);
memset(r_buf,0,sizeof(r_buf));
fd=open(FIFO_SERVER,O_RDONLY|O_NONBLOCK,0);
//fd=open(FIFO_SERVER,O_RDONLY,0);
//在此处可以把读程序编译成两个不同版本：阻塞版本及非阻塞版本
if(fd==-1)
{
printf("open %s for read error\n");
exit();
}
while(1)
{
memset(r_buf,0,sizeof(r_buf));
ret_size=read(fd,r_buf,r_size);
if(ret_size==-1)
if(errno==EAGAIN)
printf("no data avlaible\n");
printf("real read bytes %d\n",ret_size);
sleep(1);
}
pause();
unlink(FIFO_SERVER);
}</span>
程序应用说明：
把读程序编译成两个不同版本：
·阻塞读版本:br
·以及非阻塞读版本nbr
把写程序编译成两个四个版本：
· 非阻塞且请求写的字节数大于PIPE_BUF版本：nbwg
· 非阻塞且请求写的字节数不大于PIPE_BUF版本：版本nbw
· 阻塞且请求写的字节数大于PIPE_BUF版本：bwg
· 阻塞且请求写的字节数不大于PIPE_BUF版本：版本bw
下面将使用br、nbr、w代替相应程序中的阻塞读、非阻塞读
验证阻塞写操作：
1 当请求写入的数据量大于PIPE_BUF时的非原子性：
nbr 1000
bwg
2 当请求写入的数据量不大于PIPE_BUF时的原子性：
nbr 1000
bw
验证非阻塞写操作：
3 当请求写入的数据量大于PIPE_BUF时的非原子性：
nbr 1000
nbwg
4 请求写入的数据量不大于PIPE_BUF时的原子性：
nbr 1000
nbw
不管写打开的阻塞标志是否设置，在请求写入的字节数大于4096时，都不保证写入的原子性。但二者有本质区别：
对于阻塞写来说，写操作在写满FIFO的空闲区域后，会一直等待，直到写完所有数据为止，请求写入的数据最终都会写入FIFO；
而非阻塞写则在写满FIFO的空闲区域后，就返回(实际写入的字节数)，所以有些数据最终不能够写入。
对于读操作的验证则比较简单，不再讨论。
命名管道提供了两种基本通信模式：字节模式和消息模式。在字节模式中，消息以一个连续的字节流的形式，在客户机与服务器之间流动。这意味着，对客户机应用和服务器应用来说，在任何一个特定的时间段内，它们不能准确知道有多少字节从管道中读入或者写入管道。因此，在一方写入某个数量的字节，并不表示在另一方会读出等量的字节。这样一来，客户机和服务器在传输数据的时候，便不必关心数据的内容。而在消息模式中，客户机和服务器则通过一系列不连续的数据单位，进行数据的收发。每次在管道上发出了一条消息后，它必须作为一条完整的消息读入。
命名管道最大的特点便是建立一个简单的客户机／服务器程序设计体系。在这个体系结构中，在客户机与服务器之间，数据既可单向传递，亦可双向流动。这一点相当重要，因为我们可以自由地收发数据，无论应用程序是一个客户机还是一个服务器。对命名管道服务器和客户机来说，两者最大的区别在于：服务器是唯一一个有权创建命名管道的进程，也只有它才能接受管道客户机的连接请求。对一个客户机应用来说，它只能同一个现成的命名管道服务器建立连接。在客户机应用和服务器应用之间，一旦建好连接，两个进程都能对标准的Wi n 3 2函数，在管道上进行数据读取与写入。这些包括R e a d F i l e和Wr i t e F i l e等。
要想实现一个命名管道服务器，要求必须开发一个应用程序，通过它创建命名管道的一个或多个“实例”，再由客户机进行访问。对服务器来说，管道实例实际就是一个句柄，用于从本地或远程客户机应用接受一个连接请求。按下述步骤行事，便可写出一个最基本的服务器应用：
1) 使用API函数CreatNamedPipe，创建一个命名管道实例句柄。
2) 使用API函数ConnectNamedPipe，在命名管道实例上监听客户机连接请求。
3) 分别使用ReadFile和WriteFile这两个A P I函数，从客户机接收数据，或将数据发给客户机。
4) 使用API函数DisconnectNamedPipe，关闭命名管道连接。
5) 使用API函数CloseHandle，关闭命名管道实例句柄。
实现一个命名管道客户机时，要求开发一个应用程序，令其建立与某个命名管道服务器的连接。注意客户机不可创建命名管道实例。然而，客户机可打开来自服务器的、现成的实例。下述步骤讲解了如何编写一个基本的客户机应用：
1) 用API函数WaitNamedPipe，等候一个命名管道实例可供自己使用。
2) 用API函数CreatFile，建立与命名管道的连接。
3) 用API函数WriteFile和ReadFile，分别向服务器发送数据，或从中接收数据。
4) 用API函数CloseHandle，关闭打开的命名管道会话
系统内核对于管道和FIFO的唯一限制为：OPEN_MAX和PIPE_BUF;
OPEN_MAX：一个进程在任意时刻可以打开的最大描述符数。
PIPE_BUF标识一个管道可以原子写入管道和FIFO的最大字节数，并不是管道或FIFO的容量。
关于这两个系统限制，POSIX标准中都有定义的不变最小值：POSIX_OPEN_MAX和_POSIX_PIPE_BUF，这两个宏是POSXI标准定义的编译时确定的值，他们是标准定义的且不会改变的，POSIX标准关于这两个值的限制为：
cout<<_POSIX_OPEN_MAX<<endl;
cout<<_POSIX_PIPE_BUF<<endl;
//运行结果为：
20
512
我们都知道，关于POSIX的每个不变最小值都有一个具体的系统的实现值，这些是实现值由具体的系统决定，通过调用以下函数在运行时确定这个实现值：
#include <unistd.h>
//成功返回具体的值，失败返回-1
long sysconf(int name);
long fpathconf(int filedes, int name);
long pathconf(char *path, int name);
其中sysconf是用于返回系统限制值，这些值是以_SC_开头的常量，pathconf和fpathconf是用于返回与文件和目录相关的运行时的限制值，这些值都是以_PC_开头的常量；
下面是在Linux 2.6.18下的测试代码：
cout<<sysconf(_SC_OPEN_MAX)<<endl;
cout<<pathconf(FIFO_PATH, _PC_PATH_MAX)<<endl;
//运行结果为：
1024
4096
当然上面两个系统限制值的具体实现值也可以通过ulimit命令来查看
[root@idcserver program]# ulimit -a
open files (-n) 1024
pipe size (512 bytes, -p) 8
这两个值在Linux 2.6.18下都是不允许修改的，也是没有必要修改的。
标签：进程间通信 管道通信 命名管道 linux管道 windows管道
原文地址：http://blog.csdn.net/shltsh/article/details/46525805
