Linux进程间通信—管道

Linux下的进程通信手段基本上是从UNIX平台上的进程通信手段继承而来的。而对UNIX发展做出重大贡献的两大主力AT&T的贝尔实验室及BSD（加州大学伯克利分校的伯克利软件发布中心）在进程间的通信方面的侧重点有所不同。前者是对UNIX早期的进程间通信手段进行了系统的改进和扩充，形成了"system V IPC"，其通信进程主要局限在单个计算机内；后者则跳过了该限制，形成了基于套接口（socket）的进程间通信机制。而Linux则把两者的优势都继承了下来

linux进程间通信(IPC)有几种方式，下面将将简单的简述一下：

# 管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。

# 有名管道 (named pipe):有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。

# 信号量( semophore ):信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。主要作为进程间以及同一进程内不同线程之间的同步和互斥手段。

# 信号 ( sinal ):信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生，一个进程收到一个信号与处理器收到一个中断请求效果上可以说是一样的。

# 消息队列( message queue ):消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。具有写权限的进程可以按照一定的规则向消息队列中添加新消息；对消息队列有读权限的进程则可以从消息队列中读取消息。

# 共享内存( shared memory ) ：共享内存是最快的 IPC 方式。映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号量配合使用，来实现进程间的同步和通信。这种通信方式需要依靠某种同步机制，如互斥锁和信号量等。

# 套接字( socket ):套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同及其间的进程通信。用于网络中不同机器之间的进程间通信，应用非常广泛。

Unix系统中

实现进程间通信的方法很多，而且不幸的是，极少方法能在所有的Unix系统中进行移植

（唯一一种是半双工的管道，这也是最原始的一种通信方式）。而Linux作为一种新兴的操

作系统，几乎支持所有的Unix下常用的进程间通信方法：管道、消息队列、共享内存、信

号量、套接口等等。下面我们将逐一介绍。

 

 

 

一．管道（pipe）

管道是Linux支持的最初IPC方式，管道可分为无名管道，有名管道等。

（一）无名管道，它具有几个特点：

1）  管道是半双工的，只能支持数据的单向流动；两进程间需要通信时需要建立起两个管道；

2）  无名管道使用pipe()函数创建，只能用于父子进程或者兄弟进程之间；

3）  管道对于通信的两端进程而言，实质上是一种独立的文件，只存在于内存中；

4）  数据的读写操作：一个进程向管道中写数据，所写的数据添加在管道缓冲区的尾部；另一个进程在管道中缓冲区的头部读数据。

   

（二）有名管道

有名管道也是半双工的，不过它允许没有亲缘关系的进程间进行通信。具体点说就是，有名管道提供了一个路径名与之进行关联，以FIFO（先进先出）的形式存在于文件系统中。这样即使是不相干的进程也可以通过FIFO相互通信，只要他们能访问已经提供的路径。

值得注意的是，只有在管道有读端时，往管道中写数据才有意义。否则，向管道写数据的进程会接收到内核发出来的SIGPIPE信号；应用程序可以自定义该信号处理函数，或者直接忽略该信号。

 

在Linux文本流中，我们已经讲解了如何在shell中使用管道连接多个进程。同样，许多编程语言中，也有一些命令用以实现类似的机制，比如在Python子进程中使用Popen和PIPE，在C语言中也有popen库函数来实现管道 (shell中的管道就是根据此编写的)。管道是由内核管理的一个缓冲区(burrer)，相当于我们放入内存中的一个纸条。管道的一端连接一个进程的输出。这个进程会向管道中放入信息。管道的另一端连接一个进程的输入，这个进程取出被放入管道的信息。一个缓冲区不需要很大，它被设计成为环形的数据结构，以便管道可以被循环利用。当管道中没有信息的话，从管道中读取的进程会等待，直到另一端的进程放入信息。当管道被放满信息的时候，尝试放入信息的进程会等待，直到另一端的进程取出信息。当两个进程都终结的时候，管道也自动消失。

从原理上，管道利用fork机制建立(参考Linux进程基础和Linux从程序到进程），从而让两个进程可以连接到同一个PIPE上。最开始的时候，上面的两个箭头都连接在同一个进程Process 1上(连接在Process 1上的两个箭头)。当fork复制进程的时候，会将这两个连接也复制到新的进程(Process 2)。随后，每个进程关闭自己不需要的一个连接 (两个黑色的箭头被关闭; Process 1关闭从PIPE来的输入连接，Process 2关闭输出到PIPE的连接)，这样，剩下的红色连接就构成了如上图的PIPE。

由于基于fork机制，所以管道只能用于父进程和子进程之间，或者拥有相同祖先的两个子进程之间 (有亲缘关系的进程之间)。为了解决这一问题，Linux提供了FIFO方式连接进程。FIFO又叫做命名管道(named PIPE)。

FIFO (First in, First out)为一种特殊的文件类型，它在文件系统中有对应的路径。当一个进程以读(r)的方式打开该文件，而另一个进程以写(w)的方式打开该文件，那么内核就会在这两个进程之间建立管道，所以FIFO实际上也由内核管理，不与硬盘打交道。之所以叫FIFO，是因为管道本质上是一个先进先出的队列数据结构，最早放入的数据被最先读出来(好像是传送带，一头放货，一头取货)，从而保证信息交流的顺序。FIFO只是借用了文件系统(file system, 参考Linux文件管理背景知识)来为管道命名。写模式的进程向FIFO文件中写入，而读模式的进程从FIFO文件中读出。当删除FIFO文件时，管道连接也随之消失。FIFO的好处在于我们可以通过文件的路径来识别管道，从而让没有亲缘关系的进程之间建立连接。

 

 

 

 

 几种传统IPC实际上有很悠久的历史，所以其实现方式也并不完善 (比如说我们需要某个进程负责删除建立的IPC)。一个共同的特征是它们并不使用文件操作的API。对于任何一种IPC来说，你都可以建立多个连接，并使用键值(key)作为识别的方式。我们可以在一个进程中中通过键值来使用的想要那一个连接 (比如多个消息队列，而我们选择使用其中的一个)。键值可以通过某种IPC方式在进程间传递(比如说我们上面说的PIPE，FIFO或者写入文件)，也可以在编程的时候内置于程序中。

在几个进程共享键值的情况下，这些传统IPC非常类似于多线程共享资源的方式(参看Linux多线程与同步):

多进程协作可以帮助我们充分利用多核和网络时代带来的优势。多进程可以有效解决计算瓶颈的问题。互联网通信实际上也是一个进程间通信的问题，只不过这多个进程分布于不同的电脑上。网络连接是通过socket实现的。由于socket内容庞大，所以我们不在这里深入。一个小小的注解是，socket也可以用于计算机内部进程间的通信。

管道是进程间通信中最古老的方式，它包括无名管道和有名管道两种，前者用于父进

程和子进程间的通信，后者用于运行于同一台机器上的任意两个进程间的通信。

　　无名管道由pipe（）函数创建：

　　 #include <unistd.h>

　　 int pipe(int filedis[2])；

　　参数filedis返回两个文件描述符：filedes[0]为读而打开，filedes[1]为写而打开。

filedes[1]的输出是filedes[0]的输入。下面的例子示范了如何在父进程和子进程间实现通信。

#define INPUT 0

#define OUTPUT 1

void main() {

int file_descriptors[2];

 

pid_t pid;

char buf[256];

int returned_count;

 

pipe(file_descriptors);

 

if((pid = fork()) == -1) {

printf("Error in fork ");

exit(1);

}

 

if(pid == 0) {

printf("in the spawned (child) process... ");

 

close(file_descriptors[INPUT]);

write(file_descriptors[OUTPUT], "test data", strlen("test data"));

exit(0);

} else {

 

printf("in the spawning (parent) process... ");

 

close(file_descriptors[OUTPUT]);

returned_count = read(file_descriptors[INPUT], buf, sizeof(buf));

printf("%d bytes of data received from spawned process: %s ",

returned_count, buf);

}

　　在Linux系统下，有名管道可由两种方式创建：命令行方式mknod系统调用和函数

mkfifo。下面的两种途径都在当前目录下生成了一个名为myfifo的有名管道：

　　　　方式一：mkfifo("myfifo","rw");

　　　　方式二：mknod myfifo p

　　生成了有名管道后，就可以使用一般的文件I/O函数如open、close、read、write等来

对它进行操作。下面即是一个简单的例子，假设我们已经创建了一个名为myfifo的有名管道。

 

 

#include <stdio.h>

#include <unistd.h>

void main() {

FILE * in_file;

int count = 1;

char buf[80];

in_file = fopen("mypipe", "r");

if (in_file == NULL) {

printf("Error in fdopen. ");

exit(1);

}

while ((count = fread(buf, 1, 80, in_file)) > 0)

printf("received from pipe: %s ", buf);

fclose(in_file);

}

　  

#include <stdio.h>

#include <unistd.h>

void main() {

FILE * out_file;

int count = 1;

char buf[80];

out_file = fopen("mypipe", "w");

if (out_file == NULL) {

printf("Error opening pipe.");

exit(1);

}

sprintf(buf,"this is test data for the named pipe example ");

fwrite(buf, 1, 80, out_file);

fclose(out_file);

}

 

 

 

 

1、无名管道

无名管道是Linux中管道通信的一种原始方法，如图一(左)所示，它具有以下特点：

①它只能用于具有亲缘关系的进程之间的通信（也就是父子进程或者兄弟进程之间）；

②它是一个半双工的通信模式，具有固定的读端和写端；

③管道也可以看成是一种特殊的文件，对于它的读写也可以使用普通的 read()、write()等函数。但它不是普通的文件，并不属于其他任何文件系统并且只存在于内存中。

2、有名管道(FIFO)

有名管道是对无名管道的一种改进，如图1(右)所示，它具有以下特点：

①它可以使互不相关的两个进程间实现彼此通信；

②该管道可以通过路径名来指出，并且在文件系统中是可见的。在建立了管道之后，两个进程就可以把它当做普通文件一样进行读写操作，使用非常方便；

③ FIFO严格地遵循先进先出规则，对管道及FIFO的读总是从开始处返回数据，对它们的写则是把数据添加到末尾，它们不支持如 lseek()等文件定位操作。

无名管道及其系统调用

1、管道创建与管道说明

管道是基于文件描述符的通信方式，当一个管道建立时，它会创建两个文件描述符fd[0]和fd[1]，其中fd[0]固定用于读管道，而fd[1]固定用于写管道，如图2所示，这样就构成了一个半双工的通道。

管道关闭时只需要将这两个文件描述符关闭即可，可使用普通的close()函数逐个关闭各个文件描述符。

2、管道创建函数

创建管道可以调用 pipe() 来实现，如下表

3、管道读写说明

用 pipe() 创建的管道两端处于同一个进程中，由于管道主要是用于在不同的进程间通信的，因此，在实际应用中没有太大意义。实际上，通常先是创建一个管道，再调用fork()函数创建一个子进程，该子进程会继承父进程所创建的管道，这时，父子进程管道的文件描述符对应关系如下图

此时的关系看似非常复杂，实际上却已经给不同进程之间的读写创造了很好的条件。父子进程分别拥有自己的读写通道，为了实现父子进程之间的读写，只需把无关的读端或写端的文件描述符关闭即可。例如，图4中，将父进程的写端fd[1]和子进程的读端fd[0]关闭，则父子进程之间就建立起一条"子进程写入父进程读取"的通道。同样，也可以将父进程的读端fd[0]和子进程的写端fd[1]关闭，则父子进程之间就建立起一条"父进程写入子进程读取"的通道

另外，父进程还可以创建多个子进程，各个子进程都继承了相应的fd[0]和fd[1]，此时，只需要关闭相应的端口就可以建立各子进程之间的的通道。

4、管道读写注意点

● 只有在管道的读端存在时，向管道写入数据才有意义。否则，向管道写入数据的进程将收到内核传来的 SIGPIPE 信号(通常为 Broken pipe错误)。

● 向管道写入数据时，Linux将不保证写入的原子性，管道缓冲区一有空闲区域，写进程就会试图向管道写入数据。如果读进程不读取管道缓冲区中的数据，那么写进程将会一直阻塞。

● 父子进程在运行时，它们的先后次序并不能保证。因此，为了保证父子进程已经关闭了相应的文件描述符，可在两个进程中调用 sleep()函数。当然，这种调用不是很好的解决方法，以后我会用进程之间的同步与互斥机制来修改它的！

本实验中，首先创建管道，之后父进程使用 fork()函数创建子进程，最后通过关闭父进程的读描述符fd[0]和子进程的写描述符fd[1]来建立一个"父进程写入子进程读取"的管道，从而建立起它们之间的通信。

标准流管道

标准流管道函数说明

与Linux的文件操作中有基于文件流的标准I/O操作一样，管道的操作也支持基于文件流的的模式。这种基于文件流的管道主要是用来创建一个连接到另一个进程的管道，这里的"另一个进程"也就是一个可以进行一定操作的可执行文件，例如，用户执行"ls -l"或者自己编写的程序"./pipe" 等。由于这类操作很常用，因此标准流管道就将一系列的创建过程合并到一个函数 popen()中完成，它所完成的工作有以下几步:

①创建一个管道

② fork()创建一个子进程

③在父子进程中关闭不需要的文件描述符

④执行 exec 函数族调用

⑤执行函数中所指定的命令

这个函数的使用可以大大减少代码的编写量，但同时也有一些不利之处。例如，它不如前面管道创建的函数那样灵活多变，并且用popen()创建的管道必须使用标准I/O函数进行操作，而不能使用前面的 read()、write()一类不带缓冲的I/O函数。与之相对应，关闭用popen()创建的流管道必须使用函数 pclose()，该函数关闭标准I/O流，并等待命令执行结束。

函数格式

popen()函数和pclose()函数如下表：

 

 

 

有名管道(FIFO)

首先将上一节的有关有名管道的定义再贴出来

有名管道是对无名管道的一种改进，它具有以下特点：

①它可以使互不相关的两个进程间实现彼此通信；

②该管道可以通过路径名来指出，并且在文件系统中是可见的。在建立了管道之后，两个进程就可以把它当做普通文件一样进行读写操作，使用非常方便；

③ FIFO严格地遵循先进先出规则，对管道及FIFO的读总是从开始处返回数据，对它们的写则是把数据添加到末尾，它们不支持如 lseek()等文件定位操作。

有名管道的创建可以使用函数 mkfifo()，该函数类似与文件中的 open()操作，可以指定管道的路径和打开的模式。咱们还可以在命令行使用"mknod 管道名 p"来创建有名管道。

在管道创建成功后，就可以使用open()、write()和read()这些函数了。与普通文件的开发设置一样，对于为读而打开的管道可在open()中设置O_RDONLY,对于为写而打开的管道可在open()中设置O_WRONLY,在这里与普通文件不同的是阻塞问题。由于普通文件在读写时不会出现阻塞问题，而在管道的读写中却有阻塞的可能，这里的非阻塞标志可以在open()函数中设定为O_NONBLOCK。下面分别对阻塞打开和非阻塞打开的读写进行讨论。

对于读进程：

● 若该管道是阻塞打开，且当前FIFO内没有数据，则对读进程而言将一直阻塞到有数据写入。

● 若该管道是非阻塞打开，则不论FIFO内是否有数据，读进程都会立即执行读操作。即如果FIFO内没有数据，则读函数将立刻返回0。

对于写进程：

● 若该管道是阻塞打开，则写操作将一直阻塞到数据可以被写入。

● 若该管道是非阻塞打开而不能写入全部数据，则读操作进行部分写入或者调用失败。

下表列出了mkfifo()函数的语法要点

为了方便咱们查错，再对FIFO相关的出错信息进行归纳，如下表:

下面的实验中还要用到 access()函数，它的说明如下表：

access()函数的功能是确定文件或文件夹的访问权限，即检查某个文件的存取方式，比如说是只读方式、只写方式等，如果指定的存取方式有效，则函数返回0,否则函数返回-1。

 

一个用于读管道，另一个用于写管道。其中在读管道的程序中创建管道，并且作为main()函数里的参数由用户输入要写入的内容；读管道的程序会读出用户写入到管道的内容。这两个程序采用的是阻塞式读写管道模式。

写管道的程序如下：

读管道程序如下

编写保存上述两个文件后分别使用命令：gcc fifo_write.c -o fifo_write和命令：gcc fifo_read.c -o fifo_read编译。

为了能更好的观察运行效果，需要把这两个程序分别在终端里运行，在这里首先启动读管道程序。读管道进程在建立管道后就开始循环地从管道里读出内容，如果没有数据可读，则一直阻塞到写管道进程向管道写入数据。在启动了写管道程序后，读进程能够从管道里读出用户的输入内容，程序运行结果如下：

 

 

 

 

 

普通的Linux shell都允许重定向，而重定向使用的就是管道。例如：

ps | grep vsftpd .管道是单向的、先进先出的、无结构的、固定大小的字节流，它把一个进程的标准输出和另一个进程的标准输入连接在一起。写进程在管道的尾端写入数据，读进程在管道的道端读出数据。数据读出后将从管道中移走，其它读进程都不能再读到这些数据。管道提供了简单的流控制机制。进程试图读空管道时，在有数据写入管道前，进程将一直阻塞。同样，管道已经满时，进程再试图写管道，在其它进程从管道中移走数据之前，写进程将一直阻塞。管道主要用于不同进程间通信。

 

1.管道创建与关闭

创建一个简单的管道，可以使用系统调用pipe()。它接受一个参数，也就是一个包括两个整数的数组。如果系统调用成功，此数组将包括管道使用的两个文件描述符。创建一个管道之后，一般情况下进程将产生一个新的进程。

系统调用：pipe();

原型：int pipe(int fd[2]);

返回值：如果系统调用成功，返回0。如果系统调用失败返回-1：

errno=EMFILE(没有空亲的文件描述符）

      EMFILE（系统文件表已满）

      EFAULT（fd数组无效）

注意：fd[0]用于读取管道，fd[1]用于写入管道。

图见附件

2.管道的创建

#include<unistd.h>

#include<errno.h>

#include<stdio.h>

#include<stdlib.h>

int main()

{

int pipe_fd[2];

if(pipe(pipe_fd)<0){

printf("pipe create error ");

return -1;

}

else

printf("pipe create success ");

close(pipe_fd[0]);

close(pipe_fd[1]);

}

3.管道的读写

管道主要用于不同进程间通信。实际上，通常先创建一个管道，再通过fork函数创建一个子进程。图见附件。

子进程写入和父进程读的命名管道：图见附件

管道读写注意事项：

可以通过打开两个管道来创建一个双向的管道。但需要在子理程中正确地设置文件描述符。必须在系统调用fork()中调用pipe()，否则子进程将不会继承文件描述符。当使用半双工管道时，任何关联的进程都必须共享一个相关的祖先进程。因为管道存在于系统内核之中，所以任何不在创建管道的进程的祖先进程之中的进程都将无法寻址它。而在命名管道中却不是这样。管道实例见：pipe_rw.c

#include<unistd.h>

#include<memory.h>

#include<errno.h>

#include<stdio.h>

#include<stdlib.h>

int main()

{

int pipe_fd[2];

pid_t pid;

char buf_r[100];

char* p_wbuf;

int r_num;

memset(buf_r,0,sizeof(buf_r));数组中的数据清0；

if(pipe(pipe_fd)<0){

printf("pipe create error ");

return -1;

}

if((pid=fork())==0){

printf(" ");

close(pipe_fd[1]);

sleep(2);

if((r_num=read(pipe_fd[0],buf_r,100))>0){

printf("%d numbers read from be pipe is %s ",r_num,buf_r);

}

close(pipe_fd[0]);

exit(0);

}else if(pid>0){

close(pipe_fd[0]);

if(write(pipe_fd[1],"Hello",5)!=-1)

printf("parent write success! ");

if(write(pipe_fd[1]," Pipe",5)!=-1)

printf("parent wirte2 succes! ");

close(pipe_fd[1]);

sleep(3);

waitpid(pid,NULL,0);

exit(0);

}

}

4.标准流管道

与linux中文件操作有文件流的标准I/O一样，管道的操作也支持基于文件流的模式。接口函数如下：

库函数：popen();

原型：FILE *open (char *command,char *type);

返回值：如果成功，返回一个新的文件流。如果无法创建进程或者管道，返回NULL。管道中数据流的方向是由第二个参数type控制的。此参数可以是r或者w，分别代表读或写。但不能同时为读和写。在Linux 系统下，管道将会以参数type中第一个字符代表的方式打开。所以，如果你在参数type中写入rw，管道将会以读的方式打开。

使用popen()创建的管道必须使用pclose()关闭。其实，popen/pclose和标准文件输入/输出流中的fopen()/fclose()十分相似。

库函数：pclose();

原型：int pclose(FILE *stream);

返回值：返回系统调用wait4()的状态。

如果stream无效，或者系统调用wait4()失败，则返回-1。注意此库函数等待管道进程运行结束，然后关闭文件流。库函数pclose()在使用popen（）创建的进程上执行wait4()函数，它将破坏管道和文件系统。

流管道的例子。

#include<stdio.h>

#include<unistd.h>

#include<stdlib.h>

#include<fcntl.h>

#define BUFSIZE 1024

int main(){

FILE *fp;

char *cmd="ps -ef";

char buf[BUFSIZE];

buf[BUFSIZE]='';

if((fp=popen(cmd,"r"))==NULL)

 perror("popen");

while((fgets(buf,BUFSIZE,fp))!=NULL)

 printf("%s",buf);

pclose(fp);

exit(0);

}

5.命名管道（FIFO）

命名管道和一般的管道基本相同，但也有一些显著的不同：

A、命名管道是在文件系统中作为一个特殊的设备文件而存在的。

B、不同祖先的进程之间可以通过管道共享数据。

C、当共享管道的进程执行完所有的I/O操作以后，命名管道将继续保存在文件系统中以便以后使用。

管道只能由相关进程使用，它们共同的祖先进程创建了管道。但是，通过FIFO，不相关的进程也能交换数据。

命名管道创建与操作

#include<sys/types.h>

#include<sys/stat.h>

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

返回：若成功则为0，若出错返回-1

一旦已经用mkfifo创建了一个FIFO，就可用open打开它。确实，一般的文件I/O函数(close,read,write,unlink等）都可用于FIFO。当打开一个FIFO时，非阻塞标（O_NONBLOCK）产生下列影响：

（1）在一般情况中（没有说明O_NONBLOCK),只读打开要阻塞到某个其他进程为写打开此FIFO。类似，为写而打开一个FIFO要阻塞到某个其他进程为读而打开它。

（2）如果指一了O_NONBLOCK，则只读打开立即返回。但是，如果没有进程已经为读而打开一个FIFO，那么只写打开将出错返回，其errno是ENXIO。类似于管道，若写一个尚无进程为读而打开的FIFO，则产生信号SIGPIPE。若某个FIFO的最后一个写进程关闭了该FIFO，则将为该FIFO的读进程产生一个文件结束标志。

FIFO相关出错信息：

EACCES（无存取权限）

EEXIST（指定文件不存在）

ENAMETOOLONG（路径名太长）

ENOENT（包含的目录不存在）

ENOSPC（文件系统余空间不足）

ENOTDIR（文件路径无效）

EROFS（指定的文件存在于只读文件系统中）

 

 

fifo_write.c 

#include<sys/types.h>

#include<sys/stat.h>

#include<errno.h>

#include<fcntl.h>

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#define FIFO "/tmp/myfifo"

main(int argc,char** argv)

{

char buf_r[100];

int fd;

int nread;

if((mkfifo(FIFO,O_CREAT|O_EXCL)<0)&&(errno!=EEXIST))

printf("cannot create fifoserver ");

printf("Preparing for reading bytes.... ");

memset(buf_r,0,sizeof(buf_r));

fd=open(FIFO,O_RDONLY|O_NONBLOCK,0);

if(fd==-1)

{

perror("open");

exit(1);

}

while(1){

memset(buf_r,0,sizeof(buf_r));

if((nread=read(fd,buf_r,100))==-1){

if(errno==EAGAIN)

printf("no data yet ");

}

printf("read %s from FIFO ",buf_r);

sleep(1);

}

pause();

unlink(FIFO);

}

 

fifo_read.c

#include<sys/types.h>

#include<sys/stat.h>

#include<errno.h>

#include<fcntl.h>

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#define FIFO_SERVER "/tmp/myfifo"

main(int argc,char** argv)

{

int fd;

char w_buf[100];

int nwrite;

if(fd==-1)

if(errno==ENXIO)

printf("open error;no reading process ");

fd=open(FIFO_SERVER,O_WRONLY|O_NONBLOCK,0);

if(argc==1)

printf("Please send something ");

strcpy(w_buf,argv[1]);

if((nwrite=write(fd,w_buf,100))==-1)

{

if(errno==EAGAIN)

printf("The FIFO has not been read yet. Please try later ");

}

else 

printf("write %s to the FIFO ",w_buf);

}

 

 

 

 

 

1、管道概述及相关API应用

1.1 管道相关的关键概念

管道是Linux支持的最初Unix IPC形式之一，具有以下特点：

• 管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道；
• 只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）；
• 单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在与内存中。
• 数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据。

  1.2管道的创建：

  #include <unistd.h>
  

  int pipe(int fd[2])
  

  该函数创建的管道的两端处于一个进程中间，在实际应用中没有太大意义，因此，一个进程在由pipe()创建管道后，一般再fork一个子进程，然后通过管道实现父子进程间的通信（因此也不难推出，只要两个进程中存在亲缘关系，这里的亲缘关系指的是具有共同的祖先，都可以采用管道方式来进行通信）。

  1.3管道的读写规则：

  管道两端可分别用描述字fd[0]以及fd[1]来描述，需要注意的是，管道的两端是固定了任务的。即一端只能用于读，由描述字fd[0]表示，称其为管道读端；另一端则只能用于写，由描述字fd[1]来表示，称其为管道写端。如果试图从管道写端读取数据，或者向管道读端写入数据都将导致错误发生。一般文件的I/O函数都可以用于管道，如close、read、write等等。

  从管道中读取数据：

• 如果管道的写端不存在，则认为已经读到了数据的末尾，读函数返回的读出字节数为0；
• 当管道的写端存在时，如果请求的字节数目大于PIPE_BUF，则返回管道中现有的数据字节数，如果请求的字节数目不大于PIPE_BUF，则返回管道中现有数据字节数（此时，管道中数据量小于请求的数据量）；或者返回请求的字节数（此时，管道中数据量不小于请求的数据量）。注：（PIPE_BUF在include/linux/limits.h中定义，不同的内核版本可能会有所不同。Posix.1要求PIPE_BUF至少为512字节，red hat 7.2中为4096）。

  关于管道的读规则验证：

   /**************
  

   * readtest.c *
  

   **************/
  

  #include <unistd.h>
  

  #include <sys/types.h>
  

  #include <errno.h>
  

  main()
  

  {
  

      int pipe_fd[2];
  

      pid_t pid;
  

      char r_buf[100];
  

      char w_buf[4];
  

      char* p_wbuf;
  

      int r_num;
  

      int cmd;
  

      memset(r_buf,0,sizeof(r_buf));
  

      memset(w_buf,0,sizeof(r_buf));
  

      p_wbuf=w_buf;
  

      if(pipe(pipe_fd)<0)
  

      {
  

          printf("pipe create error
  ");
  

          return -1;
  

      }
  

      if((pid=fork())==0)
  

      {
  

          printf("
  ");
  

          close(pipe_fd[1]);
  

          sleep(3);//确保父进程关闭写端

          r_num=read(pipe_fd[0],r_buf,100);
  

  printf(    "read num is %d   the data read from the pipe is %d
  ",r_num,atoi(r_buf));
  

          close(pipe_fd[0]);
  

          exit();
  

      }
  

      else if(pid>0)
  

      {
  

      close(pipe_fd[0]);//read
  

      strcpy(w_buf,"111");
  

      if(write(pipe_fd[1],w_buf,4)!=-1)
  

          printf("parent write over
  ");
  

      close(pipe_fd[1]);//write
  

          printf("parent close fd[1] over
  ");
  

      sleep(10);
  

      }    
  

  }
  

   /**************************************************
  

   * 程序输出结果：

   * parent write over
  

   * parent close fd[1] over
  

   * read num is 4   the data read from the pipe is 111
  

   * 附加结论：

   * 管道写端关闭后，写入的数据将一直存在，直到读出为止.
  

   ****************************************************/
  

  向管道中写入数据：

• 向管道中写入数据时，linux将不保证写入的原子性，管道缓冲区一有空闲区域，写进程就会试图向管道写入数据。如果读进程不读走管道缓冲区中的数据，那么写操作将一直阻塞。 
• 注：只有在管道的读端存在时，向管道中写入数据才有意义。否则，向管道中写入数据的进程将收到内核传来的SIFPIPE信号，应用程序可以处理该信号，也可以忽略（默认动作则是应用程序终止）。

  对管道的写规则的验证1：写端对读端存在的依赖性

  #include <unistd.h>
  

  #include <sys/types.h>
  

  main()
  

  {
  

      int pipe_fd[2];
  

      pid_t pid;
  

      char r_buf[4];
  

      char* w_buf;
  

      int writenum;
  

      int cmd;
  

      memset(r_buf,0,sizeof(r_buf));
  

      if(pipe(pipe_fd)<0)
  

      {
  

          printf("pipe create error
  ");
  

          return -1;
  

      }
  

      if((pid=fork())==0)
  

      {
  

          close(pipe_fd[0]);
  

          close(pipe_fd[1]);
  

          sleep(10);    
  

          exit();
  

      }
  

      else if(pid>0)
  

      {
  

      sleep(1);  //等待子进程完成关闭读端的操作

      close(pipe_fd[0]);//write
  

      w_buf="111";
  

      if((writenum=write(pipe_fd[1],w_buf,4))==-1)
  

          printf("write to pipe error
  ");
  

      else    
  

          printf("the bytes write to pipe is %d 
  ", writenum);
  

      close(pipe_fd[1]);
  

      }    
  

  }
  

  则输出结果为： Broken pipe,原因就是该管道以及它的所有fork()产物的读端都已经被关闭。如果在父进程中保留读端，即在写完pipe后，再关闭父进程的读端，也会正常写入pipe，读者可自己验证一下该结论。因此，在向管道写入数据时，至少应该存在某一个进程，其中管道读端没有被关闭，否则就会出现上述错误（管道断裂,进程收到了SIGPIPE信号，默认动作是进程终止）

  对管道的写规则的验证2：linux不保证写管道的原子性验证

  #include <unistd.h>
  

  #include <sys/types.h>
  

  #include <errno.h>
  

  main(int argc,char**argv)
  

  {
  

      int pipe_fd[2];
  

      pid_t pid;
  

      char r_buf[4096];
  

      char w_buf[4096*2];
  

      int writenum;
  

      int rnum;
  

      memset(r_buf,0,sizeof(r_buf));    
  

      if(pipe(pipe_fd)<0)
  

      {
  

          printf("pipe create error
  ");
  

          return -1;
  

      }
  

      if((pid=fork())==0)
  

      {
  

          close(pipe_fd[1]);
  

          while(1)
  

          {
  

          sleep(1);    
  

          rnum=read(pipe_fd[0],r_buf,1000);
  

          printf("child: readnum is %d
  ",rnum);
  

          }
  

          close(pipe_fd[0]);
  

          exit();
  

      }
  

      else if(pid>0)
  

      {
  

      close(pipe_fd[0]);//write
  

      memset(r_buf,0,sizeof(r_buf));    
  

      if((writenum=write(pipe_fd[1],w_buf,1024))==-1)
  

          printf("write to pipe error
  ");
  

      else    
  

          printf("the bytes write to pipe is %d 
  ", writenum);
  

      writenum=write(pipe_fd[1],w_buf,4096);
  

      close(pipe_fd[1]);
  

      }    
  

  }
  

  输出结果：

  the bytes write to pipe 1000
  

  the bytes write to pipe 1000  //注意，此行输出说明了写入的非原子性

  the bytes write to pipe 1000
  

  the bytes write to pipe 1000
  

  the bytes write to pipe 1000
  

  the bytes write to pipe 120  //注意，此行输出说明了写入的非原子性

  the bytes write to pipe 0
  

  the bytes write to pipe 0
  

  ......
  

  结论：

  写入数目小于4096时写入是非原子的！ 

  如果把父进程中的两次写入字节数都改为5000，则很容易得出下面结论： 

  写入管道的数据量大于4096字节时，缓冲区的空闲空间将被写入数据（补齐），直到写完所有数据为止，如果没有进程读数据，则一直阻塞。

  1.4管道应用实例：

  实例一：用于shell

  管道可用于输入输出重定向，它将一个命令的输出直接定向到另一个命令的输入。比如，当在某个shell程序（Bourne shell或C shell等）键入who│wc -l后，相应shell程序将创建who以及wc两个进程和这两个进程间的管道。考虑下面的命令行：

  $kill -l 运行结果见 附一。

  $kill -l | grep SIGRTMIN 运行结果如下：

  30) SIGPWR    31) SIGSYS    32) SIGRTMIN    33) SIGRTMIN+1
  

  34) SIGRTMIN+2    35) SIGRTMIN+3    36) SIGRTMIN+4    37) SIGRTMIN+5
  

  38) SIGRTMIN+6    39) SIGRTMIN+7    40) SIGRTMIN+8    41) SIGRTMIN+9
  

  42) SIGRTMIN+10    43) SIGRTMIN+11    44) SIGRTMIN+12    45) SIGRTMIN+13
  

  46) SIGRTMIN+14    47) SIGRTMIN+15    48) SIGRTMAX-15    49) SIGRTMAX-14
  

  实例二：用于具有亲缘关系的进程间通信

  下面例子给出了管道的具体应用，父进程通过管道发送一些命令给子进程，子进程解析命令，并根据命令作相应处理。

  #include <unistd.h>
  

  #include <sys/types.h>
  

  main()
  

  {
  

      int pipe_fd[2];
  

      pid_t pid;
  

      char r_buf[4];
  

      char** w_buf[256];
  

      int childexit=0;
  

      int i;
  

      int cmd;
  

      memset(r_buf,0,sizeof(r_buf));
  

      if(pipe(pipe_fd)<0)
  

      {
  

          printf("pipe create error
  ");
  

          return -1;
  

      }
  

      if((pid=fork())==0)
  

      //子进程：解析从管道中获取的命令，并作相应的处理

      {
  

          printf("
  ");
  

          close(pipe_fd[1]);
  

          sleep(2);
  

          while(!childexit)
  

          {    
  

              read(pipe_fd[0],r_buf,4);
  

              cmd=atoi(r_buf);
  

              if(cmd==0)
  

              {
  

  printf("child: receive command from parent over
   now child process exit
  ");
  

                  childexit=1;
  

              }
  

                

                 else if(handle_cmd(cmd)!=0)
  

                  return;
  

              sleep(1);
  

          }
  

          close(pipe_fd[0]);
  

          exit();
  

      }
  

      else if(pid>0)
  

      //parent: send commands to child
  

      {
  

      close(pipe_fd[0]);
  

      w_buf[0]="003";
  

      w_buf[1]="005";
  

      w_buf[2]="777";
  

      w_buf[3]="000";
  

      for(i=0;i<4;i++)
  

          write(pipe_fd[1],w_buf[i],4);
  

      close(pipe_fd[1]);
  

      }    
  

  }
  

  //下面是子进程的命令处理函数（特定于应用）：

  int handle_cmd(int cmd)
  

  {
  

  if((cmd<0)||(cmd>256))
  

  //suppose child only support 256 commands
  

      {
  

      printf("child: invalid command 
  ");
  

      return -1;
  

      }
  

  printf("child: the cmd from parent is %d
  ", cmd);
  

  return 0;
  

  }
  

  1.5管道的局限性

  管道的主要局限性正体现在它的特点上：

• 只支持单向数据流；
• 只能用于具有亲缘关系的进程之间；
• 没有名字；
• 管道的缓冲区是有限的（管道制存在于内存中，在管道创建时，为缓冲区分配一个页面大小）；
• 管道所传送的是无格式字节流，这就要求管道的读出方和写入方必须事先约定好数据的格式，比如多少字节算作一个消息（或命令、或记录）等等；

  回页首

  2、有名管道概述及相关API应用

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

  管道应用的一个重大限制是它没有名字，因此，只能用于具有亲缘关系的进程间通信，在有名管道（named pipe或FIFO）提出后，该限制得到了克服。FIFO不同于管道之处在于它提供一个路径名与之关联，以FIFO的文件形式存在于文件系统中。这样，即使与FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过FIFO相互通信（能够访问该路径的进程以及FIFO的创建进程之间），因此，通过FIFO不相关的进程也能交换数据。值得注意的是，FIFO严格遵循先进先出（first in first out），对管道及FIFO的读总是从开始处返回数据，对它们的写则把数据添加到末尾。它们不支持诸如lseek()等文件定位操作。

  2.2有名管道的创建

  #include <sys/types.h>
  

  #include <sys/stat.h>
  

  int mkfifo(const char * pathname, mode_t mode)
  

  该函数的第一个参数是一个普通的路径名，也就是创建后FIFO的名字。第二个参数与打开普通文件的open()函数中的mode 参数相同。如果mkfifo的第一个参数是一个已经存在的路径名时，会返回EEXIST错误，所以一般典型的调用代码首先会检查是否返回该错误，如果确实返回该错误，那么只要调用打开FIFO的函数就可以了。一般文件的I/O函数都可以用于FIFO，如close、read、write等等。

  2.3有名管道的打开规则

  有名管道比管道多了一个打开操作：open。

  FIFO的打开规则：

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

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

  对打开规则的验证参见 附2。

  2.4有名管道的读写规则

  从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读写规则进行验证。

  程序1：写FIFO的程序

  #include <sys/types.h>
  

  #include <sys/stat.h>
  

  #include <errno.h>
  

  #include <fcntl.h>
  

  #define FIFO_SERVER "/tmp/fifoserver"
  

  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
  ");
  

      if(fd==-1)
  

          if(errno==ENXIO)
  

              printf("open error; no reading process
  ");
  

            

           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
  ");
  

      }
  

      else 
  

          printf("real write num is %d
  ",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
  ");
  

  }
  

  程序2：与程序1一起测试写FIFO的规则，第一个命令行参数是请求从FIFO读出的字节数

  #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
  ",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
  ");
  

          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
  ");
  

          printf("real read bytes %d
  ",ret_size);
  

          sleep(1);
  

      }    
  

      pause();
  

      unlink(FIFO_SERVER);
  

  }
  

  程序应用说明：

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

• 阻塞读版本:br
• 以及非阻塞读版本nbr

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

• 非阻塞且请求写的字节数大于PIPE_BUF版本：nbwg
• 非阻塞且请求写的字节数不大于PIPE_BUF版本：版本nbw
• 阻塞且请求写的字节数大于PIPE_BUF版本：bwg
• 阻塞且请求写的字节数不大于PIPE_BUF版本：版本bw

  下面将使用br、nbr、w代替相应程序中的阻塞读、非阻塞读

  验证阻塞写操作：

• 当请求写入的数据量大于PIPE_BUF时的非原子性：
• nbr 1000
• bwg
• 当请求写入的数据量不大于PIPE_BUF时的原子性：
• nbr 1000
• bw

  验证非阻塞写操作：

• 当请求写入的数据量大于PIPE_BUF时的非原子性：
• nbr 1000
• nbwg
• 请求写入的数据量不大于PIPE_BUF时的原子性：
• nbr 1000
• nbw

  不管写打开的阻塞标志是否设置，在请求写入的字节数大于4096时，都不保证写入的原子性。但二者有本质区别：

  对于阻塞写来说，写操作在写满FIFO的空闲区域后，会一直等待，直到写完所有数据为止，请求写入的数据最终都会写入FIFO；

  而非阻塞写则在写满FIFO的空闲区域后，就返回(实际写入的字节数)，所以有些数据最终不能够写入。

  对于读操作的验证则比较简单，不再讨论。

  2.5有名管道应用实例

  在验证了相应的读写规则后，应用实例似乎就没有必要了。

  回页首

  小结：

  管道常用于两个方面：（1）在shell中时常会用到管道（作为输入输入的重定向），在这种应用方式下，管道的创建对于用户来说是透明的；（2）用于具有亲缘关系的进程间通信，用户自己创建管道，并完成读写操作。

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

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

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

  附1：kill -l 的运行结果，显示了当前系统支持的所有信号：

  1) SIGHUP     2) SIGINT     3) SIGQUIT     4) SIGILL
  

  5) SIGTRAP     6) SIGABRT     7) SIGBUS     8) SIGFPE
  

  9) SIGKILL    10) SIGUSR1    11) SIGSEGV    12) SIGUSR2
  

  13) SIGPIPE    14) SIGALRM    15) SIGTERM    17) SIGCHLD
  

  18) SIGCONT    19) SIGSTOP    20) SIGTSTP    21) SIGTTIN
  

  22) SIGTTOU    23) SIGURG    24) SIGXCPU    25) SIGXFSZ
  

  26) SIGVTALRM    27) SIGPROF    28) SIGWINCH    29) SIGIO
  

  30) SIGPWR    31) SIGSYS    32) SIGRTMIN    33) SIGRTMIN+1
  

  34) SIGRTMIN+2    35) SIGRTMIN+3    36) SIGRTMIN+4    37) SIGRTMIN+5
  

  38) SIGRTMIN+6    39) SIGRTMIN+7    40) SIGRTMIN+8    41) SIGRTMIN+9
  

  42) SIGRTMIN+10    43) SIGRTMIN+11    44) SIGRTMIN+12    45) SIGRTMIN+13
  

  46) SIGRTMIN+14    47) SIGRTMIN+15    48) SIGRTMAX-15    49) SIGRTMAX-14
  

  50) SIGRTMAX-13    51) SIGRTMAX-12    52) SIGRTMAX-11    53) SIGRTMAX-10
  

  54) SIGRTMAX-9    55) SIGRTMAX-8    56) SIGRTMAX-7    57) SIGRTMAX-6
  

  58) SIGRTMAX-5    59) SIGRTMAX-4    60) SIGRTMAX-3    61) SIGRTMAX-2
  

  62) SIGRTMAX-1    63) SIGRTMAX
  

  除了在此处用来说明管道应用外，接下来的专题还要对这些信号分类讨论。

  附2：对FIFO打开规则的验证（主要验证写打开对读打开的依赖性）

  #include <sys/types.h>
  

  #include <sys/stat.h>
  

  #include <errno.h>
  

  #include <fcntl.h>
  

  #define FIFO_SERVER "/tmp/fifoserver"
  

  int handle_client(char*);
  

  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
  ");
  

      handle_client(FIFO_SERVER);
  

  }
  

  int handle_client(char* arg)
  

  {
  

  int ret;
  

  ret=w_open(arg);
  

  switch(ret)
  

  {
  

      case 0:
  

      {    
  

      printf("open %s error
  ",arg);
  

      printf("no process has the fifo open for reading
  ");
  

      return -1;
  

      }
  

      case -1:
  

      {
  

          printf("something wrong with open the fifo except for ENXIO");
  

          return -1;
  

      }
  

      case 1:
  

      {
  

          printf("open server ok
  ");
  

          return 1;
  

      }
  

      default:
  

      {
  

          printf("w_no_r return ----
  ");
  

          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;
  

  }