Linux进程通信：命名管道FIFO小结

Linux 下进程之间通信可以用命名管道FIFO 完成。

命名管道是一种特殊类型的文件，因为Linux 中所有事物都是文件，它在文件系统中以文件名的形式存在。

在程序中，我们可以使用两个不同的函数调用来建立管道：
#include <sys/types.h>
#include <sys/stat.h> int mkfifo(const char *filename, mode_t mode);
int mknode(const char *filename, mode_t mode | S_IFIFO, (dev_t) 0 );
下面先来创建一个管道：
view plaincopy to clipboardprint? #include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
int main()
{
int res = mkfifo("/tmp/my_fifo", 0777);
if (res == 0)
{
printf("FIFO created\n");
}
exit(EXIT_SUCCESS);
}
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
int main()
{
int res = mkfifo("/tmp/my_fifo", 0777); if (res == 0)
{
printf("FIFO created\n");
} exit(EXIT_SUCCESS);
}
编译这个程序：
gcc -o fifol.c fifo
运行这个程序：
$ ./fifo1
用ls 命令查看所创建的管道
$ ls -lF /tmp/my_fifo
prwxr-xr-x 1 root root 0 05-08 20:10 /tmp/my_fifo|
注意：Is命令的输出结果中的第一个字符为p，表示这是一个管道。

最后的|符号是由Is命令
的-F 选项添加的，它也表示是这是一个管道。

虽然，我们所设置的文件创建模式为“0777”但它被用户掩码（umask）设置（022）给改
变了，这与普通文件创建是一样的，所以文件的最终模式为755。

打开FIFO 一个主要的限制是，程序不能是O_RDWR 模式打开FIFO 文件进行读写操作，这样做的后果未明确定义。

这个限制是有道理的，因为我们使用FIFO 只是为了单身传递数
据，所以没有必要使用O_RDWR 模式。

如果一个管道以读/写方式打开FIFO ，进程就会从这个管道读回它自己的输出。

如果确实需要在程序之间双向传递数据，最好使用一对FIFO，一个方向使用一个。

当一个Linux进程被阻塞时，它并不消耗CPU资源，这种进程的同步方式对CPU而言是非
常有效率的。

有关Linux 下命名管道FIFO 的读写规则可以参见之前所写的一篇文章：Linux 命名管道FIFO 的读写规则。

、实验：使用FIFO 实现进程间通信两个独立的程序：
1. 生产者程序，它在需要时创建管道，然后尽可能快地向管道中写入数据。

2. 消费者程序，它从FIFO 中读取数据并丢弃它们。

生产者程序fifo2.c ：
view plaincopy to clipboardprint?
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#define FIFO_NAME "/tmp/Linux/my_fifo"
#define BUFFER_SIZE PIPE_BUF
#define TEN_MEG (1024 * 1024 * 10)
int main()
{
int pipe_fd;
int res;
int open_mode = O_WRONL Y;
int bytes = 0;
char buffer[BUFFER_SIZE + 1];
if (access(FIFO_NAME, F_OK) == -1)
{
res = mkfifo(FIFO_NAME, 0777);
if (res != 0)
{
fprintf(stderr, "Could not create fifo %s\n", FIFO_NAME); exit(EXIT_FAILURE);
}
}
printf("Process %d opening FIFO O_WRONL Y\n", getpid()); pipe_fd = open(FIFO_NAME, open_mode);
printf("Process %d result %d\n", getpid(), pipe_fd);
if (pipe_fd != -1)
{
while (bytes < TEN_MEG)
{
res = write(pipe_fd, buffer, BUFFER_SIZE);
if (res == -1)
{
fprintf(stderr, "Write error on pipe\n"); exit(EXIT_FAILURE);
}
bytes += res;
}
close(pipe_fd);
}
else
{
exit(EXIT_FAILURE);
}
printf("Process %d finish\n", getpid()); exit(EXIT_SUCCESS);
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#define FIFO_NAME "/tmp/Linux/my_fifo"
#define BUFFER_SIZE PIPE_BUF
#define TEN_MEG (1024 * 1024 * 10)
int main()
{
int pipe_fd;
int res;
int open_mode = O_WRONL Y;
int bytes = 0;
char buffer[BUFFER_SIZE + 1];
if (access(FIFO_NAME, F_OK) == -1)
{
res = mkfifo(FIFO_NAME, 0777);
if (res != 0)
{
fprintf(stderr, "Could not create fifo %s\n", FIFO_NAME); exit(EXIT_FAILURE);
}
}
printf("Process %d opening FIFO O_WRONL Y\n", getpid()); pipe_fd = open(FIFO_NAME, open_mode);
printf("Process %d result %d\n", getpid(), pipe_fd);
if (pipe_fd != -1)
{
while (bytes < TEN_MEG)
{
res = write(pipe_fd, buffer, BUFFER_SIZE);
if (res == -1)
{
fprintf(stderr, "Write error on pipe\n"); exit(EXIT_FAILURE);
}
bytes += res;
}
close(pipe_fd);
}
else
{
exit(EXIT_FAILURE);
}
printf("Process %d finish\n", getpid());
exit(EXIT_SUCCESS);
}
消费者程序fifo3.c ：
view plaincopy to clipboardprint?
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#define FIFO_NAME "/tmp/Linux/my_fifo"
#define BUFFER_SIZE PIPE_BUF
int main()
{
int pipe_fd;
int res;
int open_mode = O_RDONL Y; char buffer[BUFFER_SIZE + 1]; int bytes = 0;
memset(buffer, '\0', sizeof(buffer));
printf("Process %d opeining FIFO O_RDONL Y\n", getpid()); pipe_fd = open(FIFO_NAME, open_mode);
printf("Process %d result %d\n", getpid(), pipe_fd);
if (pipe_fd != -1)
{
do{
res = read(pipe_fd, buffer, BUFFER_SIZE); bytes += res;
}while(res > 0);
close(pipe_fd);
}
else
{
exit(EXIT_FAILURE);
}
printf("Process %d finished, %d bytes read\n", getpid(), bytes); exit(EXIT_SUCCESS);
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#define FIFO_NAME "/tmp/Linux/my_fifo"
#define BUFFER_SIZE PIPE_BUF int main()
{
int pipe_fd;
int res;
int open_mode = O_RDONL Y; char
buffer[BUFFER_SIZE + 1];
int bytes = 0;
memset(buffer, '\0', sizeof(buffer));
printf("Process %d opeining FIFO O_RDONL Y\n", getpid()); pipe_fd = open(FIFO_NAME, open_mode);
printf("Process %d result %d\n", getpid(), pipe_fd);
if (pipe_fd != -1)
{
do{
res = read(pipe_fd, buffer, BUFFER_SIZE); bytes += res;
}while(res > 0);
close(pipe_fd);
}
else
{
exit(EXIT_FAILURE);
}
printf("Process %d finished, %d bytes read\n", getpid(), bytes); exit(EXIT_SUCCESS);
}
编译这两个程序：
gcc -o fifo2 fifo2.c
gcc -o fifo3 fifo3.c
运行这两个程序：
[root@localhost chaper12]# ./fifo2 & a后台执行，写数据
[2] 23121
Process 23121 opening FIFO O_WRONL Y
[root@localhost chaper12]# time ./fifo3 a读数据
Process 24155 opeining FIFO O_RDONL Y
Process 23121 result 3
Process 24155 result 3
Process 23121 finish
Process 24155 finished, 10485760 bytes read
[2]- Done ./fifo2
real 0m0.214s
user 0m0.000s
sys 0m0.179s
以上两个程序均是使用阻塞模式FIFO。

Linux 会安排好这两个进程之间的调试，使它们在
可以运行的时候运行，在不能运行的时候阻塞。

因此，写进程将在管道满时阻塞，读进程将在管道空时阻塞。

虚拟机上，time 命令显示，读进程只运行了0.2 秒的时间，却读取了10M 字节的数据。

这说明管道在程序之间传递数据是非常有效的。

二、实验：使用FIFO 的客户/服务器应用程序
利用FIFO 实现一个客户/服务器的应用程序，服务器进程接受请求，对它们进程处理，最后把结果数据返回给发送请求的客户方。

首先建立一个头文件client.h ，它定义了客户和服务器程序都要用到的数据结构，并包含了必要的头文件。

view plaincopy to clipboardprint?
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#define SERVER_FIFO_NAME "/tmp/Linux/chaper12/server_fifo" #define CLIENT_FIFO_NAME "/tmp/Linux/chaper12/client_%d_fifo"
#define BUFFER_SIZE PIPE_BUF
#define MESSAGE_SIZE 20
#define NAME_SIZE 256
typedef struct message {
pid_t client_pid;
char data[MESSAGE_SIZE + 1];
}message;
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#define SERVER_FIFO_NAME "/tmp/Linux/chaper12/server_fifo"
#define CLIENT_FIFO_NAME "/tmp/Linux/chaper12/client_%d_fifo" #define BUFFER_SIZE
PIPE_BUF
#define MESSAGE_SIZE 20
#define NAME_SIZE 256
typedef struct message
{
pid_t client_pid;
char data[MESSAGE_SIZE + 1];
}message;
接下来是服务器程序server.c,在这一部分，是以只读阻塞模式打开服务器管道，用于接收客户发送过来的数据，这些数据采用message结构体圭寸装。

view plaincopy to clipboardprint?
#include "client.h"
int main()
{
int server_fifo_fd;
int client_fifo_fd;
int res;
char client_fifo_name[NAME_SIZE];
message msg;
char *p;
if (mkfifo(SERVER_FIFO_NAME, 0777) == -1)
{
fprintf(stderr, "Sorry, create server fifo failure!\n"); exit(EXIT_FAILURE);
}
server_fifo_fd = open(SERVER_FIFO_NAME, O_RDONL Y); if (server_fifo_fd == -1)
{
fprintf(stderr, "Sorry, server fifo open failure!\n"); exit(EXIT_FAILURE);
}
sleep(5);
while (res = read(server_fifo_fd, &msg, sizeof(msg)) > 0) {
p = msg.data;
while (*p)
{
*p = toupper(*p);
++p;
}
sprintf(client_fifo_name, CLIENT_FIFO_NAME, msg.client_pid); client_fifo_fd =
open(client_fifo_name, O_WRONL Y);
if (client_fifo_fd == -1)
{
fprintf(stderr, "Sorry, client fifo open failure!\n"); exit(EXIT_FAILURE);
}
write(client_fifo_fd, &msg, sizeof(msg)); close(client_fifo_fd);
}
close(server_fifo_fd); unlink(SERVER_FIFO_NAME); exit(EXIT_SUCCESS);
}
#include "client.h"
int main()
{
int server_fifo_fd;
int client_fifo_fd;
int res;
char client_fifo_name[NAME_SIZE];
message msg;
char *p;
if (mkfifo(SERVER_FIFO_NAME, 0777) == -1)
{ fprintf(stderr, "Sorry, create server fifo failure!\n"); exit(EXIT_FAILURE);
}
server_fifo_fd = open(SERVER_FIFO_NAME, O_RDONL Y);
if (server_fifo_fd == -1)
{ fprintf(stderr, "Sorry, server fifo open failure!\n"); exit(EXIT_FAILURE);
}
sleep(5);
while (res = read(server_fifo_fd, &msg, sizeof(msg)) > 0)
{
p = msg.data; while (*p) { *p = toupper(*p);
++p;
}
sprintf(client_fifo_name, CLIENT_FIFO_NAME, msg.client_pid); client_fifo_fd =
open(client_fifo_name, O_WRONL Y); if (client_fifo_fd == -1)
{ fprintf(stderr, "Sorry, client fifo open failure!\n"); exit(EXIT_FAILURE);
}
write(client_fifo_fd, &msg, sizeof(msg)); close(client_fifo_fd);
}
close(server_fifo_fd); unlink(SERVER_FIFO_NAME);
exit(EXIT_SUCCESS);
}
客户端程序client.c ，这个程序用于向服务器发送消息，并接收来自服务器的回复。

view plaincopy to clipboardprint?
#include "client.h" int main()
{
int server_fifo_fd;
int client_fifo_fd;
int res;
char client_fifo_name[NAME_SIZE];
message msg;
msg.client_pid = getpid();
sprintf(client_fifo_name, CLIENT_FIFO_NAME, msg.client_pid);
if (mkfifo(client_fifo_name, 0777) == -1)
{
fprintf(stderr, "Sorry, create client fifo failure!\n"); exit(EXIT_FAILURE);
}
server_fifo_fd = open(SERVER_FIFO_NAME, O_WRONL Y);
if (server_fifo_fd == -1)
{
fprintf(stderr, "Sorry, open server fifo failure!\n"); exit(EXIT_FAILURE);
}
sprintf(msg.data, "Hello from %d", msg.client_pid); printf("%d sent %s ", msg.client_pid, msg.data); write(server_fifo_fd, &msg, sizeof(msg));
client_fifo_fd = open(client_fifo_name, O_RDONLY); if (client_fifo_fd == -1)
{
fprintf(stderr, "Sorry, client fifo open failure!\n"); exit(EXIT_FAILURE);
}
res = read(client_fifo_fd, &msg, sizeof(msg));
if (res > 0)
{
printf("received:%s\n", msg.data);
close(client_fifo_fd); close(server_fifo_fd); unlink(client_fifo_name);
exit(EXIT_SUCCESS);
}
#include "client.h"
int main()
{
int server_fifo_fd;
int client_fifo_fd;
int res;
char client_fifo_name[NAME_SIZE];
message msg;
msg.client_pid = getpid();
sprintf(client_fifo_name, CLIENT_FIFO_NAME, msg.client_pid);
if (mkfifo(client_fifo_name, 0777) == -1)
{
fprintf(stderr, "Sorry, create client fifo failure!\n"); exit(EXIT_FAILURE);
}
server_fifo_fd = open(SERVER_FIFO_NAME, O_WRONL Y); if (server_fifo_fd == -1) {
fprintf(stderr, "Sorry, open server fifo failure!\n"); exit(EXIT_FAILURE);
}
sprintf(msg.data, "Hello from %d", msg.client_pid); printf("%d sent %s ", msg.client_pid, msg.data); write(server_fifo_fd, &msg, sizeof(msg));
client_fifo_fd = open(client_fifo_name, O_RDONLY);
if (client_fifo_fd == -1)
{ fprintf(stderr, "Sorry, client fifo open failure!\n"); exit(EXIT_FAILURE);
}
res = read(client_fifo_fd, &msg, sizeof(msg));
if (res > 0)
{ printf("received:%s\n", msg.data);
}
close(client_fifo_fd); close(server_fifo_fd); unlink(client_fifo_name);
exit(EXIT_SUCCESS);
}
编译程序：
gcc -o server server.c
gcc -o clie nt clie nt.c
测试这个程序，我们需要一个服务器进程和多个客户进程。

启动，我们使
为了让多个客户进程在同一时间
用了shell 命令：
[root@localhost chaper12]# ./server &
[26] 5171
[root@localhost chaper12]# for i in 1 2 3 4 5; do ./client & done
[27] 5172
[28] 5173
[29] 5174
[30] 5175
[31] 5176 [root@localhost chaper12]# 5172 sent Hello from 5172 received:HELLO FROM 5172 5173 sent Hello from 5173 received:HELLO FROM 5173
5174 sent Hello from 5174 received:HELLO FROM 5174
5175 sent Hello from 5175 received:HELLO FROM 5175
5176 sent Hello from 5176 received:HELLO FROM 5176
分析这个例子，服务器以只读模式创建它的FIFO 并阻塞，直到第一个客户以写方式打开同一现个FIFO 来建立连接为止。

此时，服务器进程解除阻塞并执行sleep 语句，这使得来自客户的数据排除等候。

在实际应用程序中，应该把sleep 语句删除，这里面只是为了演示当有多个客户请求同时到达时，程序的正确操作方法。

与此同时，在客户端打开服务器FIFO 后，它创建自己唯一的一个命名管道以读取服务器返回的数据。

完成这些工作后，客户发送数据给服务器（如果管道满或服务器仍处于休眠就阻塞），并阻塞于对自己FIFO 的read 调用上，等待服务器响应。

接收到来自客户的数据后，服务器处于它，然后以写的方式打开客户管道并将处理后的数据返回，这将解
除客户端的阻塞状态，客户程序就可以从自己的管道里面读取服务器返回的数据了。

整个处理过程不断重复，直到最后一个客户关闭服务器管道为止，这将使服务器的read 调用失败（返回0），因为已经没有进程以写方式打开服务器管道了。

如果这是一个真正的服务器进程的话，它还需要继续等待其他客户的请求，我们就需要对它进行修改，有两种方法：
（1）对它自己的服务器管道打开一个文件描述符，这样read 调用将阻塞而不是返
回0。

（2）当read调用返回0时，关闭并重新打开服务器管道，使服务器进程阻塞在open
调用处以等待客户的到来，就像它最初启动时那样。