Linux进程间通信（二）FIFO

最新推荐文章于 2025-06-28 13:57:09 发布

a1232345

最新推荐文章于 2025-06-28 13:57:09 发布

阅读量1.1k

点赞数 1

CC 4.0 BY-SA版权

分类专栏： Linux进程与线程文章标签： Linux FIFO 命名管道

本文链接：https://blog.youkuaiyun.com/a1232345/article/details/50611894

Linux进程与线程专栏收录该内容

34 篇文章

订阅专栏

本文深入探讨FIFO（先进先出）在操作系统中的应用，包括阻塞与非阻塞模式下的读写操作细节，以及如何利用FIFO实现生产者-消费者模型和客户-服务器架构中的数据交换。

1.从FIFO中读取数据：

约定：如果一个进程为了从FIFO中读取数据而阻塞打开了FIFO，那么称该进程内的读操作为设置了阻塞标志的读操作。

（1）如果有进程写打开FIFO，且当前FIFO为空，则对于设置了阻塞标志的读操作来说，将一直阻塞下去，直到有数据可以读时才继续执行；对于没有设置阻塞标志的读操作来说，则返回0个字节，当前errno值为EAGAIN，提醒以后再试。

（2）对于设置了阻塞标志的读操作来说，造成阻塞的原因有两种：一、当前FIFO内有数据，但有其它进程在读这些数据；二、FIFO本身为空。

解阻塞的原因是：FIFO中有新的数据写入，不论写入数据量的大小，也不论读操作请求多少数据量，只要有数据写入即可。

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

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

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

2.从FIFO中写入数据：

约定：如果一个进程为了向FIFO中写入数据而阻塞打开FIFO，那么称该进程内的写操作为设置了阻塞标志的写操作。

FIFO的长度是需要考虑的一个很重要因素。系统对任一时刻在一个FIFO中可以存在的数据长度是有限制的。它由#define PIPE_BUF定义，在头文件limits.h中。在Linux和许多其他类UNIX系统中，它的值通常是4096字节，Red Hat Fedora9下是4096，但在某些系统中它可能会小到512字节。

虽然对于只有一个FIFO写进程和一个FIFO的读进程而言，这个限制并不重要，但只使用一个FIFO并允许多个不同进程向一个FIFO读进程发送请求的情况是很常见的。如果几个不同的程序尝试同时向FIFO写数据，能否保证来自不同程序的数据块不相互交错就非常关键了à也就是说，每个写操作必须“原子化”。

一、对于设置了阻塞标志的写操作：

（1）当要写入的数据量不大于PIPE_BUF时，Linux将保证写入的原子性。如果此时管道空闲缓冲区不足以容纳要写入的字节数，则进入睡眠，直到当缓冲区中能够容纳要写入的字节数时，才开始进行一次性写操作。即写入的数据长度小于等于PIPE_BUF时，那么或者写入全部字节，或者一个字节都不写入，它属于一个一次性行为，具体要看FIFO中是否有足够的缓冲区。

（2）当要写入的数据量大于PIPE_BUF时，Linux将不再保证写入的原子性。FIFO缓冲区一有空闲区域，写进程就会试图向管道写入数据，写操作在写完所有请求写的数据后返回。

二、对于没有设置阻塞标志的写操作：

（1）当要写入的数据量不大于PIPE_BUF时，Linux将保证写入的原子性。如果当前FIFO空闲缓冲区能够容纳请求写入的字节数，写完后成功返回；如果当前FIFO空闲缓冲区不能够容纳请求写入的字节数，则返回EAGAIN错误，提醒以后再写。

（2）当要写入的数据量大于PIPE_BUF时，Linux将不再保证写入的原子性。在写满所有FIFO空闲缓冲区后，写操作返回。

生产-消费者模型：

写进程：

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

#define TEN_MEG (1024*10*10)

int main(int agrc, char *argv[])
{
	const char *fifo_file = "/tmp/myfifo";
	int pipe_fd, data_fd;
	char *buffer = NULL;
	int res = 0, bytes = 0;
	buffer = malloc(TEN_MEG); //要写入的数据
	memset(buffer,'0',TEN_MEG);

	if(access(fifo_file, F_OK) == -1) //创建前要先做判断，如果已经存在，则再调用mkfifo会失败
	{
		if(mkfifo(fifo_file,0666) < 0)
		{
			fprintf(stderr, "Could not create fifo %s\n", fifo_file);
			exit(1);
		}
	}
	printf("Process %d opening FIFO O_WRONLY\n", getpid());
	pipe_fd = open(fifo_file, O_WRONLY);
	if(pipe_fd == -1)
	{
		fprintf(stderr, "Could not create fifo %s\n", fifo_file);
		exit(1);
	}
	printf("Process %d pipe %d\n", getpid(), pipe_fd);
	while(bytes < TEN_MEG)
	{
		res = write(pipe_fd,buffer,PIPE_BUF);
		if(res < 0)
		{
			fprintf(stderr,"write error on pipe\n");
			exit(1);
		}
		bytes += res;
	}

	close(pipe_fd);
	free(buffer);
	printf("Process %d finished, %d bytes write\n", getpid(), bytes);
	exit(0);
}

读进程：

#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <limits.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int pipe_fd,data_fd;
	char buffer[PIPE_BUF];
	int res = 0;
	int bytes = 0;

	printf("Process %d opening FIFO O_RDONLY\n", getpid());
	pipe_fd = open("/tmp/myfifo",O_RDONLY);
	if(pipe_fd < 0)
	{
		fprintf(stderr,"open fifo %s error\n","/tmp/myfifo");
		exit(1);
	}

	printf("Process %d pipe %d\n", getpid(), pipe_fd);
	data_fd = open("data_read.txt",O_RDWR|O_CREAT, 0644);
	if(data_fd < 0)
	{
		fprintf(stderr,"create file %s failed\n","data_read.txt");
		exit(1);
	}

	do
	{
		res = read(pipe_fd,buffer,PIPE_BUF);
		bytes += res;
		write(data_fd,buffer,res);

	}while(res > 0);

	close(pipe_fd);
	close(data_fd);
	unlink("/tmp/myfifo");
	printf("Process %d finished, %d bytes read\n", getpid(), bytes);
	exit(0);
}

运行结果

local@ubuntu:~/Practice$ ./fifowrite&
[2] 9127
local@ubuntu:~/Practice$ Process 9127 opening FIFO O_WRONLY

local@ubuntu:~/Practice$ jobs; sleep 5; jobs
[1]- 运行中 ./fifowrite &
[1]- 运行中 ./fifowrite &

local@ubuntu:~/Practice$ time ./fiforead
Process 9148 opening FIFO O_RDONLY
Process 9127 pipe 3
Process 9148 pipe 3
Process 9127 finished, 102400 bytes write
Process 9148 finished, 102400 bytes read
[2]+ 已完成 ./fifowrite

real 0m0.005s
user 0m0.000s
sys 0m0.000s

分析：两个程序都使用阻塞模式的FIFO，为了让大家更清楚地看清楚阻塞究竟是怎么一回事，首先我们运行fifowrite，并把它放到后台去运行。这时调用jobs命令，可以看到它确实在后台运行着，过了5秒后，再调用jobs命令，可以看到进程fifowrite还没有结束，它还在继续运行。因为fifowrite进程的open调用是阻塞的，在fiforead还没有运行时，也就没有其他的进程以读方式打开同一个FIFO，所以它就一直在等待，open被阻塞，没有返回。然后，当我们进程fiforead运行时（为了查看性能，在time命令中运行），fifowrite中的open调用返回，进程开始继续工作，然后结束进程。而fiforead的open调用虽然也是阻塞模式，但是fifowrite早已运行，即早有另一个进程以写方式打开同一个FIFO，所以open调用立即返回。

使用FIFO的客户/服务器应用程序

FIFO的真正优势在于：服务器可以是一个长期运行的进程（例如守护进程），而且与其客户可以无亲缘关系。

作为服务器的守护进程以某个众所周知的路径名创建一个FIFO，并打开该FIFO来读。此后某个时刻启动的客户打开该FIFO来写，并将其请求通过该FIFO发送出去。（客户到服务器）

每个客户在启动时创建自己的FIFO，所用的路径名含有自己的进程ID。每个客户把自己的请求写入服务器的众所周知的FIFO中，该请求含有客户的进程ID以及一个请求文件路径名，服务器根据客户进程ID可以知道客户FIFO的路径名。

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

#ifndef PRACTICE_SERVER_CLIENT_CLIENT_H_
#define PRACTICE_SERVER_CLIENT_CLIENT_H_

#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <limits.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

#define SERVER_FIFO_NAME "/tmp/server_fifo"
#define CLIENT_FIFO_NAME "/tmp/client_fifo_%d"

#define MESSAGE_SIZE 20
#define NAME_SIZE 256

typedef struct message{
	pid_t client_pid;
	char data[MESSAGE_SIZE + 1];
}message;

#endif /* PRACTICE_SERVER_CLIENT_CLIENT_H_ */

接下来是服务器程序server.c，在这一部分，是以只读阻塞模式打开服务器管道，用于接收客户发送过来的数据，这些数据采用message结构体封装。

#include "client.h"

int main(void)
{
	int server_fifo_fd, client_fifo_fd;
	char *p;
	char client_fifo[NAME_SIZE];
	message msg;
	memset(&msg, 0, sizeof(msg));

	//创建服务器FIFO
	if(access(SERVER_FIFO_NAME, F_OK) == -1)
	{
		if(mkfifo(SERVER_FIFO_NAME, 0644) == -1)
		{
			fprintf(stderr,"can't creat server fifo\n");
			exit(EXIT_FAILURE);
		}
	}
	//以只读的方式打开服务器FIFO
	server_fifo_fd = open(SERVER_FIFO_NAME, O_RDONLY);
	if(server_fifo_fd == -1)
	{
		fprintf(stderr,"server open server fifo %s failed\n", SERVER_FIFO_NAME);
		unlink(SERVER_FIFO_NAME);
		exit(EXIT_FAILURE);
	}

	sleep(2);
	while(read(server_fifo_fd, &msg, sizeof(msg)) > 0)
	{
		//处理读到的数据
		p = msg.data;
		while(*p)
		{
			*p = toupper(*p);
			p++;
		}
		//根据客户端进程ID打开客户端FIFO
		snprintf(client_fifo, sizeof(client_fifo), CLIENT_FIFO_NAME, msg.client_pid);
		client_fifo_fd = open(client_fifo, O_WRONLY);
		if(client_fifo_fd == -1)
		{
			fprintf(stderr,"open client fifo %s failed\n", client_fifo);
			unlink(SERVER_FIFO_NAME);
			exit(EXIT_FAILURE);
		}

		if(write(client_fifo_fd, &msg, sizeof(msg)) < 0)
		{
			fprintf(stderr,"write client fifo %s failed\n", client_fifo);
			exit(EXIT_FAILURE);
		}
		close(client_fifo_fd);
	}

	close(server_fifo_fd);
	unlink(SERVER_FIFO_NAME);
	exit(0);
}

客户端程序client.c，这个程序用于向服务器发送消息，并接收来自服务器的回复。注意创建client_fifo和打开的顺序。

#include "client.h"

int main(void)
{
	int client_fifo_fd, server_fifo_fd;
	int res;
	char client_fifo[NAME_SIZE];
	message msg;
	memset(&msg, 0, sizeof(msg));

	msg.client_pid = getpid();
	snprintf(msg.data, sizeof(msg.data), "hello from %d", msg.client_pid);
	snprintf(client_fifo, sizeof(client_fifo), CLIENT_FIFO_NAME, msg.client_pid);

	//创建client_fifo
	if(access(client_fifo, F_OK) == -1)
	{
		if(mkfifo(client_fifo, 0644) < 0)
		{
			fprintf(stderr,"create client fifo %s failed\n", client_fifo);
			exit(EXIT_FAILURE);
		}
	}

	//打开server fifo
	if((server_fifo_fd = open(SERVER_FIFO_NAME, O_WRONLY)) == -1)
	{
		fprintf(stderr,"client %d open server fifo %s failed\n", msg.client_pid, SERVER_FIFO_NAME);
		unlink(client_fifo);
		exit(EXIT_FAILURE);
	}
	if(write(server_fifo_fd, &msg, sizeof(msg)) < 0)
	{
		fprintf(stderr,"write server fifo %s failed\n", SERVER_FIFO_NAME);
		exit(EXIT_FAILURE);
	}
	printf("%d sent %s ", msg.client_pid, msg.data);

	//读来自server的response
	if((client_fifo_fd = open(client_fifo, O_RDONLY)) == -1)
	{
		fprintf(stderr,"open client fifo %s failed\n", client_fifo);
		unlink(client_fifo);
		exit(EXIT_FAILURE);
	}
	memset(&msg, 0, sizeof(msg));
	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);
	exit(0);
}

编译程序：

gcc –o server server.c

gcc –o client client.c

测试这个程序，我们需要一个服务器进程和多个客户进程。为了让多个客户进程在同一时间启动，我们使用了shell脚本：

  1 #! /bin/bash
  2 for i in 1 2 3 4 5
  3 do
  4     ./client&
  5 done

local@ubuntu:~/Practice/server_client$ ./server&
[1] 12608
local@ubuntu:~/Practice/server_client$ jobs
[1]+ 运行中 ./server &
local@ubuntu:~/Practice/server_client$ ./client.sh
local@ubuntu:~/Practice/server_client$ 12610 sent hello from 12610 Received:HELLO FROM 12610
12614 sent hello from 12614 Received:HELLO FROM 12614
12611 sent hello from 12611 Received:HELLO FROM 12611
12612 sent hello from 12612 Received:HELLO FROM 12612
12613 sent hello from 12613 Received:HELLO FROM 12613

分析这个例子，服务器以只读模式创建它的FIFO并阻塞，直到第一个客户以写方式打开同一现个FIFO来建立连接为止。此时，服务器进程解除阻塞并执行sleep语句，这使得来自客户的数据排除等候。在实际应用程序中，应该把sleep语句删除，这里面只是为了演示当有多个客户请求同时到达时，程序的正确操作方法。

与此同时，在客户端打开服务器FIFO后，它创建自己唯一的一个命名管道以读取服务器返回的数据。完成这些工作后，客户发送数据给服务器（如果管道满或服务器仍处于休眠就阻塞），并阻塞于对自己FIFO的read调用上，等待服务器响应。

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

整个处理过程不断重复，直到最后一个客户关闭服务器管道为止，这将使服务器的read调用失败（返回0），因为已经没有进程以写方式打开服务器管道了。如果这是一个真正的服务器进程的话，它还需要继续等待其他客户的请求，我们就需要对它进行修改，有两种方法：

（1）对它自己的服务器管道打开一个文件描述符，这样read调用将阻塞而不是返回0。

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