Linux进程间通信(二)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调用处以等待客户的到来,就像它最初启动时那样。


你可能感兴趣的:(linux,fifo,命名管道)