进程间通信之管道篇

何为进程间通信

每个进程各自有不同的用户地址空间,任何一个进程的全局变量在另一个进程中都是看不到的。所以进程之间如果要交换数据就必须通过内核。

在内核中开辟一块缓冲区,进程1把数据从用户空间拷到内核缓冲区,进程2再从内核缓冲区把数据读走,内核提供的这种机制称为进程间通信(IPC,InterProcess Communication)。        

进程间通信的本质，就是要让不同的进程看到同一份资源。

进程间的通信方法有很多，今天只说管道。

何为管道

管道分为两种：匿名管道与命名管道。

何为匿名管道

匿名管道是一种最基本的IPC机制,由pipe函数创建:
         
调用pipe函数时在内核中开辟一块缓冲区(称为管道)用于通信,它有一个读端一个写端,然后通过pipefd参数传出给用户程序两个文件描述符,pipefd[0]指向管道的读端,fpipefd1]指向管道的写端。

所以管道在用户程序看起来就像一个打开的文件,通过read(filedes[0]);或者write(filedes[1]);向这个文件读写数据其实是在读写内核缓冲区。pipe函数调用成功返回0,调用失败返回-1。 开辟了管道之后如何实现两个进程间的通信呢?比如可以按下面的步骤通信。

                   

1. 父进程调用pipe开辟管道,得到两个文件描述符指向管道的两端。
2.  父进程调用fork创建子进程,那么子进程也有两个文件描述符指向同一管道。
3. 父进程关闭管道读端,子进程关闭管道写端（当然也可以反过来）。父进程可以往管道里写,子进程可以从管道里读,管道是用环形队列实现的,数据从写端流入，从读端流出,这样就实现了进程间通信。
   

因为管道是单向通信的，即单工，所以父子进程必须关闭它们各自不需要的端。其次，匿名管道是通过子进程继承父进程的文件描述符表才得以实现父子进程共同看到一份资源，所以匿名管道也就只能在有亲缘关系的进程间实现通信。

代码实现：

#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main()
{
	int fd[2];
	if (pipe(fd))
	{
		perror("pipe");
		return 1;
	}

	// 实现父进程写，子进程读
	pid_t id = fork();
	if (id < 0)
	{
		perror("fork");
		return 2;
	}
	else if (id == 0) // child
	{
		close(fd[1]);
		
		char buf[128];
		int cnt = 0;
		while (cnt++ < 5)
		{
			ssize_t _s = read(fd[0], buf, sizeof(buf));
			if (_s > 0)
			{
				buf[_s] = '\0';;
				printf("father say to child: %s\n", buf);
			}
			else if (_s == 0)
			{
				printf("father close write");
				break;
			}
			else
			{
				perror("read");
				break;
			}
		}

		close(fd[0]);
	}
	else		  // father
	{
		close(fd[0]);
		
		char * msg = "hello world";
		int cnt = 0;
		while (cnt++ < 5)
		{
			write(fd[1], msg, strlen(msg));
			sleep(1);
		}
	
		close(fd[1]);
	}
	
	return 0;
}

运行结果：

         

匿名管道的特点：

1. 单向通信
2. 具有亲缘关系的进程间通信
3. 管道生命周期随进程（管道文件描述符在进程结束后被关闭）
4. 面向字节流的服务
5. 底层实现的同步机制，无需用户在考虑（为空不允许读，为满不允许写（阻塞））

几种特殊情况：

1. 如果所有指向管道写端的文件描述符都关闭了(管道写端的引用计数等于0),而仍然有进程从管道的读端读数据,那么管道中剩余的数据都被读取后,再次read会返回0,就像读到文件末尾一样。
2. 如果有指向管道写端的文件描述符没关闭(管道写端的引用计数大于0),而持有管道写端的进程也没有向管道中写数据,这时有进程从管道读端读数据,那么管道中剩余的数据都被读取后,再次read会阻塞,直到管道中有数据可读了才读取数据并返回。
3. 如果所有指向管道读端的文件描述符都关闭了(管道读端的引用用计数等于0),这时有进程向管道的写端write,那么该进程会收到信号SIGPIPE,通常会导致进程异常终止。
4. 如果有指向管道读端的文件描述符没关闭(管道读端的引用计数大于0),而持有管道读端的进程也没有从管道中读数据,这时有进程向管道写端写数据,那么在管道被写满时再次write会阻塞,直到管道中有空位置了才写入数据并返回。
   

何为命名管道

匿名管道的缺点就是只能在有亲缘关系的进程间进行通信，针对这个缺陷，又提出来了命名管道（FIFO）的概念。FIFO不同于管道之处在于它提供一个路径名与之关联,以FIFO的文件形式存储于文件系统中。命名管道是一个设备文件,因此,即使进程与创建FIFO的进程不存在亲缘关系,只要可以访问该路径,就能够通过FIFO
相互通信。值得注意的是,FIFO(first input first output)总是按照先进先出的原则工作,第一个被写入的数据将首先从管道中读出。

创建命名管道的方式无非也就是那两种：命令和函数。而且命令和函数对应的名字是一样的，mkfifo(mknod)命令/函数。

示例代码：

server:

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

int main()
{
	// 创建管道时需要在mode参数位置传S_IFIFO,表明创建的是命名管道
	int ret = mkfifo("./.fifo", S_IFIFO | 0644);	
	if (ret < 0)
	{
		perror("mkfifo");
		return 1;
	}

	int fd = open("./.fifo", O_WRONLY);
	if (fd < 0)
	{
		perror("open");
		return 2;
	}

	int cnt = 0;
	char *msg = "hello world";
	while (cnt++ < 5)
	{
		write(fd, msg, strlen(msg));
		sleep(1);
	}

	close(fd);
	return 0;
}

client:

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

int main()
{
	int fd = open("./.fifo", O_RDONLY);
	if (fd < 0)
	{
		perror("open");
		return 2;
	}

	int cnt = 0;
	char buf[128];
	while (cnt++ < 5)
	{
		ssize_t _s = read(fd, buf, sizeof(buf) - 1);
		if (_s > 0)
		{
			buf[_s] = '\0';;
			printf("server say to client: %s\n", buf);
		}
		else if (_s == 0)
		{
			printf("server close write\n");
			break;
		}
		else
		{
			perror("read");
		}
		sleep(1);
	}

	close(fd);
	return 0;
}

运行结果：

         

命名管道创建后就可以使用了,命名管道和管道的使用方法基本是相同的。只是使用命名管道时,必须先调用open()将其打开。因为命名管道是一个存在于硬盘上的文件,而管道是存在于内存中的特殊文件。需要注意的是,调用open()打开命名管道的进程可能会被阻塞。但如果同时用读写方式(O_RDWR)打开,则一定不会导致阻塞;如果以只读方式(O_RDONLY)打开,则调用open()函数的进程将会被阻塞直到有写方打开管道;同样以写方式(O_WRONLY)打开也会阻塞直到有读方式打开道。

命名管道与匿名管道不同的地方在于即使没有亲缘关系，也可以通过FIFO来通信，且管道的生命周期不再是随进程，因为即使命名管道文件描述符被关闭，FIFO依然存在于磁盘上，是一个文件。