🍁1. 进程间通信的介绍

🍂1.1 进程间通信的概念

进程间通信简称IPCInterprocess communication进程间通信就是在不同进程之间传播或交换信息。

---

🍂1.2 进程间通信的目的

• 数据传输 一个进程需要将它的数据发送给另一个进程。
• 资源共享 多个进程之间共享同样的资源。
• 通知事件 一个进程需要向另一个或一组进程发送消息通知它它们发生了某种事件比如进程终止时需要通知其父进程。
• 进程控制 有些进程希望完全控制另一个进程的执行如Debug进程此时控制进程希望能够拦截另一个进程的所有陷入和异常并能够及时知道它的状态改变。

---

🍂1.3 进程间通信的本质

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

由于各个运行进程之间具有独立性这个独立性主要体现在数据层面而代码逻辑层面可以私有也可以公有例如父子进程因此各个进程之间要实现通信是非常困难的。

各个进程之间若想实现通信一定要借助第三方资源这些进程就可以通过向这个第三方资源写入或是读取数据进而实现进程之间的通信这个第三方资源实际上就是操作系统提供的一段内存区域。

因此进程间通信的本质就是让不同的进程看到同一份资源内存文件内核缓冲等。 由于这份资源可以由操作系统中的不同模块提供因此出现了不同的进程间通信方式。

---

🍂1.4 进程间通信的分类

管道

• 匿名管道
• 命名管道

System V IPC

• System V 消息队列
• System V 共享内存
• System V 信号量

POSIX IPC

• 消息队列
• 共享内存
• 信号量
• 互斥量
• 条件变量
• 读写锁

---

🍁2. 管道

🍂2.1 什么是管道

• 管道是Unix中最古老的进程间通信的形式。
• 我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”

who命令和wc命令都是两个程序当它们运行起来后就变成了两个进程who进程通过标准输出将数据打到“管道”当中wc进程再通过标准输入从“管道”当中读取数据至此便完成了数据的传输进而完成数据的进一步加工处理。

---

🍂2.2 匿名管道

🍃2.2.1 匿名管道的原理

匿名管道用于进程间通信且仅限于本地父子进程之间的通信。

进程间通信的本质就是让不同的进程看到同一份资源使用匿名管道实现父子进程间通信的原理就是让两个父子进程先看到同一份被打开的文件资源然后父子进程就可以对该文件进行写入或是读取操作进而实现父子进程间通信。

注意

• 这里父子进程看到的同一份文件资源是由操作系统来维护的所以当父子进程对该文件进行写入操作时该文件缓冲区当中的数据并不会进行写时拷贝。
• 管道虽然用的是文件的方案但操作系统一定不会把进程进行通信的数据刷新到磁盘当中因为这样做有IO参与会降低效率而且也没有必要。也就是说这种文件是一批不会把数据写到磁盘当中的文件换句话说磁盘文件和内存文件不一定是一一对应的有些文件只会在内存当中存在而不会在磁盘当中存在。

---

🍃2.2.2 pipe函数

pipe函数用于创建匿名管道pip函数的函数原型如下

int pipe(int pipefd[2])

pipe函数的参数是一个输出型参数数组pipefd用于返回两个指向管道读端和写端的文件描述符

数组元素	含义
pipefd[0]	管道读端的文件描述符
pipefd[1]	管道写端的文件描述符

pipe函数调用成功时返回0调用失败时返回-1。

---

🍃2.2.3 匿名管道使用步骤

在创建匿名管道实现父子进程间通信的过程中需要pipe函数和fork函数搭配使用具体步骤如下

• 父进程调用pipe函数创建管道

• 父进程创建子进程

• 父进程关闭写端子进程关闭读端

注意

• 管道只能够进行单向通信因此当父进程创建完子进程后需要确认父子进程谁读谁写然后关闭相应的读写端。
• 从管道写端写入的数据会被内核缓冲直到从管道的读端被读取。

我们可以站在文件描述符的角度再来看看这三个步骤

在以下代码当中子进程向匿名管道当中写入10行数据父进程从匿名管道当中将数据读出。

//child->write, father->read                                                                                                                                                                                                                                                                                                                                                                                                                                                        
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main()
{
	int fd[2] = { 0 };
	if (pipe(fd) < 0){ //使用pipe创建匿名管道
		perror("pipe");
		return 1;
	}
	pid_t id = fork(); //使用fork创建子进程
	if (id == 0){
		//child
		close(fd[0]); //子进程关闭读端
		//子进程向管道写入数据
		const char* msg = "hello father, I am child...";
		int count = 10;
		while (count--){
			write(fd[1], msg, strlen(msg));
			sleep(1);
		}
		close(fd[1]); //子进程写入完毕关闭文件
		exit(0);
	}
	//father
	close(fd[1]); //父进程关闭写端
	//父进程从管道读取数据
	char buff[64];
	while (1){
		ssize_t s = read(fd[0], buff, sizeof(buff));
		if (s > 0){
			buff[s] = '\0';
			printf("child send to father:%s\n", buff);
		}
		else if (s == 0){
			printf("read file end\n");
			break;
		}
		else{
			printf("read error\n");
			break;
		}
	}
	close(fd[0]); //父进程读取完毕关闭文件
	waitpid(id, NULL, 0);
	return 0;
}

---

🍃2.2.4 管道读写规则

pipe2函数与pipe函数类似也是用于创建匿名管道其函数原型如下

int pipe2(int pipefd[2], int flags);

pipe2函数的第二个参数用于设置选项。

1、当没有数据可读时

• O_NONBLOCK disableread调用阻塞即进程暂停执行一直等到有数据来为止。

• O_NONBLOCK enableread调用返回-1errno值为EAGAIN。
  2、当管道满的时候

• O_NONBLOCK disablewrite调用阻塞直到有进程读走数据。

• O_NONBLOCK enablewrite调用返回-1errno值为EAGAIN。

3、如果所有管道写端对应的文件描述符被关闭则read返回0。
4、如果所有管道读端对应的文件描述符被关闭则write操作会产生信号SIGPIPE进而可能导致write进程退出。
5、当要写入的数据量不大于PIPE_BUF时Linux将保证写入的原子性。
6、当要写入的数据量大于PIPE_BUF时Linux将不再保证写入的原子性。

---

🍃2.2.5 管道的特点

1. 管道内部自带同步与互斥机制。

我们将一次只允许一个进程使用的资源称为临界资源。管道在同一时刻只允许一个进程对其进行写入或是读取操作因此管道也就是一种临界资源。

临界资源是需要被保护的若是我们不对管道这种临界资源进行任何保护机制那么就可能出现同一时刻有多个进程对同一管道进行操作的情况进而导致同时读写、交叉读写以及读取到的数据不一致等问题。

为了避免这些问题内核会对管道操作进行同步与互斥

• 同步 两个或两个以上的进程在运行过程中协同步调按预定的先后次序运行。比如A任务的运行依赖于B任务产生的数据。
• 互斥 一个公共资源同一时刻只能被一个进程使用多个进程不能同时使用公共资源。

实际上同步是一种更为复杂的互斥而互斥是一种特殊的同步。对于管道的场景来说互斥就是两个进程不可以同时对管道进行操作它们会相互排斥必须等一个进程操作完毕另一个才能操作而同步也是指这两个不能同时对管道进行操作但这两个进程必须要按照某种次序来对管道进行操作。

也就是说互斥具有唯一性和排它性但互斥并不限制任务的运行顺序而同步的任务之间则有明确的顺序关系。

---

2. 管道的生命周期随进程。

管道本质上是通过文件进行通信的也就是说管道依赖于文件系统那么当所有打开该文件的进程都退出后该文件也就会被释放掉所以说管道的生命周期随进程。

---

3. 管道提供的是流式服务

对于进程A写入管道当中的数据进程B每次从管道读取的数据的多少是任意的这种被称为流式服务与之相对应的是数据报服务

• 流式服务 数据没有明确的分割不分一定的报文段。
• 数据报服务 数据有明确的分割拿数据按报文段拿。

---

4. 管道是半双工通信的

在数据通信中数据在线路上的传送方式可以分为以下三种

• 单工通信(Simplex Communication)单工模式的数据传输是单向的。通信双方中一方固定为发送端另一方固定为接收端。
• 半双工通信(Half Duplex)半双工数据传输指数据可以在一个信号载体的两个方向上传输但是不能同时传输。
• 全双工通信(Full Duplex)全双工通信允许数据在两个方向上同时传输它的能力相当于两个单工通信方式的结合。全双工可以同时(瞬时)进行信号的双向传输。

管道是半双工的数据只能向一个方向流动需要双方通信时需要建立起两个管道。

---

🍃2.2.6 管道的四种特殊情况

在使用管道时可能出现以下四种特殊情况

1. 写端进程不写读端进程一直读那么此时会因为管道里面没有数据可读对应的读端进程会被挂起直到管道里面有数据后读端进程才会被唤醒。
2. 读端进程不读写端进程一直写那么当管道被写满后对应的写端进程会被挂起直到管道当中的数据被读端进程读取后写端进程才会被唤醒。
3. 写端进程将数据写完后将写端关闭那么读端进程将管道当中的数据读完后就会继续执行该进程之后的代码逻辑而不会被挂起。
4. 读端进程将读端关闭而写端进程还在一直向管道写入数据那么操作系统会将写端进程杀掉。

我们可以通过以下代码看看情况四中子进程退出时究竟是收到了什么信号

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
	int fd[2] = { 0 };
	if (pipe(fd) < 0){ //使用pipe创建匿名管道
		perror("pipe");
		return 1;
	}
	pid_t id = fork(); //使用fork创建子进程
	if (id == 0){
		//child
		close(fd[0]); //子进程关闭读端
		//子进程向管道写入数据
		const char* msg = "hello father, I am child...";
		int count = 10;
		while (count--){
			write(fd[1], msg, strlen(msg));
			sleep(1);
		}
		close(fd[1]); //子进程写入完毕关闭文件
		exit(0);
	}
	//father
	close(fd[1]); //父进程关闭写端
	close(fd[0]); //父进程直接关闭读端导致子进程被操作系统杀掉
	int status = 0;
	waitpid(id, &status, 0);
	printf("child get signal:%d\n", status & 0x7F); //打印子进程收到的信号
	return 0;
}

由此可知当发生情况四时操作系统向子进程发送的是SIGPIPE信号将子进程终止的。

---

🍃2.2.7 管道的大小

管道的容量是有限的如果管道已满那么写端将阻塞或失败那么管道的最大容量是多少呢

• 方法一man

我们先使用uname -r命令查看自己使用的Linux版本。

然后man 7 pipe 中查看pipe capacity

根据man手册在2.6.11之前的Linux版本中管道的最大容量与系统页面大小相同从Linux 2.6.11往后管道的最大容量是65536字节。

---

• 方法二ulimit

ulimit -a 

根据显示管道的最大容量是 512 × 8 = 4096 512\times8=4096 512×8=4096 字节。

---

• 方法三暴力自测

若是读端进程一直不读取管道当中的数据写端进程一直向管道写入数据当管道被写满后写端进程就会被挂起。据此我们可以写出以下代码来测试管道的最大容量。

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
int main()
{
	int fd[2] = { 0 };
	if (pipe(fd) < 0){ //使用pipe创建匿名管道
		perror("pipe");
		return 1;
	}
	pid_t id = fork(); //使用fork创建子进程
	if (id == 0){
		//child 
		close(fd[0]); //子进程关闭读端
		char c = 'a';
		int count = 0;
		//子进程一直进行写入一次写入一个字节
		while (1){
			write(fd[1], &c, 1);
			count++;
			printf("%d\n", count); //打印当前写入的字节数
		}
		close(fd[1]);
		exit(0);
	}
	//father
	close(fd[1]); //父进程关闭写端

	//父进程不进行读取

	waitpid(id, NULL, 0);
	close(fd[0]);
	return 0;
}

可以看到在读端进程不进行读取的情况下写端进程最多写65536字节的数据就被操作系统挂起了也就是说我当前Linux版本中管道的最大容量是65536字节。

---

🍂2.3 命名管道

🍃2.3.1 命名管道的原理

匿名管道只能用于具有共同祖先的进程具有亲缘关系的进程之间的通信通常一个管道由一个进程创建然后该进程调用fork此后父子进程之间就可应用该管道。

如果要实现两个毫不相关进程之间的通信可以使用命名管道来做到。命名管道就是一种特殊类型的文件两个进程通过命名管道的文件名打开同一个管道文件此时这两个进程也就看到了同一份资源进而就可以进行通信了。

注意

• 普通文件是很难做到通信的即便做到通信也无法解决一些安全问题。

• 命名管道和匿名管道一样都是内存文件只不过命名管道在磁盘有一个简单的映像但这个映像的大小永远为0因为命名管道和匿名管道都不会将通信数据刷新到磁盘当中。

---

🍃2.3.2 使用命令创建命名管道

我们可以使用mkfifo命令创建一个命名管道。

p代表该文件是命名管道文件

使用这个命名管道文件就能实现两个进程之间的通信了。我们在一个进程进程A中用shell脚本每秒向命名管道写入一个字符串在另一个进程进程B当中用cat命令从命名管道当中进行读取。

现象就是当进程A启动后进程B会每秒从命名管道中读取一个字符串打印到显示器上。这就证明了这两个毫不相关的进程可以通过命名管道进行数据传输即通信。

当管道的读端进程退出后写端进程再向管道写入数据就没有意义了此时写端进程会被操作系统杀掉在这里就可以很好的得到验证当我们终止掉读端进程后因为写端执行的循环脚本是由命令行解释器bash执行的所以此时bash就会被操作系统杀掉我们的云服务器也就退出了。

---

🍃2.3.3 创建一个命名管道

在程序中创建命名管道使用mkfifo函数

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

mkfifo函数的第一个参数是pathname表示要创建的命名管道文件。

• 若pathname以路径的方式给出则将命名管道文件创建在pathname路径下。
• 若pathname以文件名的方式给出则将命名管道文件默认创建在当前路径下。注意当前路径的含义

mkfifo函数的第二个参数是mode表示创建命名管道文件的默认权限。

若想创建出来命名管道文件的权限值不受umask的影响则需要在创建文件前使用umask函数将文件默认掩码设置为0。

mkfifo函数的返回值

• 命名管道创建成功返回0。
• 命名管道创建失败返回-1。

---

🍃2.3.4 命名管道的打开规则

1. 如果当前打开操作是为读而打开FIFO时。

• O_NONBLOCK disable阻塞直到有相应进程为写而打开该FIFO。
• O_NONBLOCK enable立刻返回成功。

2. 如果当前打开操作是为写而打开FIFO时。

• O_NONBLOCK disable阻塞直到有相应进程为读而打开该FIFO。
• O_NONBLOCK enable立刻返回失败错误码为ENXIO。

---

🍃2.3.5 用命名管道实现serve&client通信

实现服务端(server)和客户端(client)之间的通信之前我们需要先让服务端运行起来我们需要让服务端运行后创建一个命名管道文件然后再以读的方式打开该命名管道文件之后服务端就可以从该命名管道当中读取客户端发来的通信信息了。

//server.cc
#include "comm.hpp"

int main()
{
	umask(0); //将文件默认掩码设置为0
	if (mkfifo(FILE_NAME, 0666) < 0){ //使用mkfifo创建命名管道文件
		perror("mkfifo");
		return 1;
	}
	int fd = open(FILE_NAME, O_RDONLY); //以读的方式打开命名管道文件
	if (fd < 0){
		perror("open");
		return 2;
	}
	char msg[128];
	while (1){
		msg[0] = '\0'; //每次读之前将msg清空
		//从命名管道当中读取信息
		ssize_t s = read(fd, msg, sizeof(msg)-1);
		if (s > 0){
			msg[s] = '\0'; //手动设置'\0'便于输出
			printf("client# %s\n", msg); //输出客户端发来的信息
		}
		else if (s == 0){
			printf("client quit!\n");
			break;
		}
		else{
			printf("read error!\n");
			break;
		}
	}
	close(fd); //通信完毕关闭命名管道文件
	return 0;
}

而对于客户端来说因为服务端运行起来后命名管道文件就已经被创建了所以客户端只需以写的方式打开该命名管道文件之后客户端就可以将通信信息写入到命名管道文件当中进而实现和服务端的通信。

客户端的代码如下

//client.cc
#include "comm.hpp"

int main()
{
	int fd = open(FILE_NAME, O_WRONLY); //以写的方式打开命名管道文件
	if (fd < 0){
		perror("open");
		return 1;
	}
	char msg[128];
	while (1){
		msg[0] = '\0'; //每次读之前将msg清空
		printf("Please Enter# "); //提示客户端输入
		fflush(stdout);
		//从客户端的标准输入流读取信息
		ssize_t s = read(0, msg, sizeof(msg)-1);
		if (s > 0){
			msg[s - 1] = '\0';
			//将信息写入命名管道
			write(fd, msg, strlen(msg));
		}
	}
	close(fd); //通信完毕关闭命名管道文件
	return 0;
}

对于如何让客户端和服务端使用同一个命名管道文件这里我们可以让客户端和服务端包含同一个头文件该头文件当中提供这个共用的命名管道文件的文件名这样客户端和服务端就可以通过这个文件名打开同一个命名管道文件进而进行通信了。

共用头文件的代码如下

//comm.hpp
#pragma once

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

#define FILE_NAME "myfifo" //让客户端和服务端使用同一个命名管道

代码编写完毕后先将服务端进程运行起来之后我们就能在客户端看到这个已经被创建的命名管道文件。

接着再将客户端也运行起来此时我们从客户端写入的信息被客户端写入到命名管道当中服务端再从命名管道当中将信息读取出来打印在服务端的显示器上该现象说明服务端是能够通过命名管道获取到客户端发来的信息的换句话说此时这两个进程之间是能够通信的。

服务端和客户端之间的退出关系

当客户端退出后服务端将管道当中的数据读完后就再也读不到数据了那么此时服务端也就会去执行它的其他代码了在当前代码中是直接退出了。

当服务端退出后客户端写入管道的数据就不会被读取了也就没有意义了那么当客户端下一次再向管道写入数据时就会收到操作系统发来的13号信号(SIGPIPE)此时客户端就被操作系统强制杀掉了。

通信是在内存当中进行的

若是我们只让客户端向管道写入数据而服务端不从管道读取数据那么这个管道文件的大小会不会发生变化呢

//server.cc
#include "comm.hpp"

int main()
{
	umask(0); //将文件默认掩码设置为0
	if (mkfifo(FILE_NAME, 0666) < 0){ //使用mkfifo创建命名管道文件
		perror("mkfifo");
		return 1;
	}
	int fd = open(FILE_NAME, O_RDONLY); //以读的方式打开命名管道文件
	if (fd < 0){
		perror("open");
		return 2;
	}
	while (1){
		//服务端不读取管道信息
	}
	close(fd); //通信完毕关闭命名管道文件
	return 0;
}

可以看到尽管服务端不读取管道当中的数据但是管道当中的数据并没有被刷新到磁盘使用ll命令看到命名管道文件的大小依旧为0也就说明了双方进程之间的通信依旧是在内存当中进行的和匿名管道通信是一样的。

---

🍃2.3.6 用命名管道实现派发计算任务

需要注意的是两个进程之间的通信并不是简单的发送字符串而已服务端是会对客户端发送过来的信息进行某些处理的。

这里我们以客户端向服务端派发计算任务为例客户端通过管道向服务端发送双操作数的计算请求服务端接收到客户端的信息后需要计算出相应的结果。

这里我们无需更改客户端的代码只需改变服务端处理通信信息的逻辑即可。

//server.cc
#include "comm.hpp"

int main()
{
	umask(0); //将文件默认掩码设置为0
	if (mkfifo(FILE_NAME, 0666) < 0){ //使用mkfifo创建命名管道文件
		perror("mkfifo");
		return 1;
	}
	int fd = open(FILE_NAME, O_RDONLY); //打开命名管道文件
	if (fd < 0){
		perror("open");
		return 2;
	}
	char msg[128];
	while (1){
		msg[0] = '\0'; //每次读之前将msg清空
		//从命名管道当中读取信息
		ssize_t s = read(fd, msg, sizeof(msg)-1);
		if (s > 0){
			msg[s] = '\0'; //手动设置'\0'便于输出
			printf("client# %s\n", msg);
			//服务端进行计算任务
		    const char* lable = "+-*/%";
			char* p = msg;
			int flag = 0;
			while (*p){
				switch (*p){
				case '+':
					flag = 0;
					break;
				case '-':
					flag = 1;
					break;
				case '*':
					flag = 2;
					break;
				case '/':
					flag = 3;
					break;
				case '%':
					flag = 4;
					break;
				}
				p++;
			}
			char* data1 = strtok(msg, "+-*/%");
			char* data2 = strtok(NULL, "+-*/%");
			int num1 = atoi(data1);
			int num2 = atoi(data2);
			int ret = 0;
			switch (flag){
			case 0:
				ret = num1 + num2;
				break;
			case 1:
				ret = num1 - num2;
				break;
			case 2:
				ret = num1 * num2;
				break;
			case 3:
				ret = num1 / num2;
				break;
			case 4:
				ret = num1 % num2;
				break;
			}
			printf("%d %c %d = %d\n", num1, lable[flag], num2, ret); //打印计算结果
		}
		else if (s == 0){
			printf("client quit!\n");
			break;
		}
		else{
			printf("read error!\n");
			break;
		}
	}
	close(fd); //通信完毕关闭命名管道文件
	return 0;
}

此时服务端接收到客户端的信息后需要进行的处理动作就不是将其打印到显示器了而是需要将信息经过进一步的处理从而得到相应的结果。

---

🍃2.3.7 用命名管道实现进程遥控

比较有意思的是我们可以通过一个进程来控制另一个进程的行为比如我们从客户端输入命令到管道当中再让服务端将管道当中的命令读取出来并执行。

下面我们只实现了让服务端执行不带选项的命令若是想让服务端执行带选项的命令可以对管道当中获取的命令进行解析处理。这里的实现非常简单只需让服务端从管道当中读取命令后创建子进程然后再进行进程程序替换即可。

这里也无需更改客户端的代码只需改变服务端处理通信信息的逻辑即可。

//server.cc
#include "comm.hpp"

int main()
{
	umask(0); //将文件默认掩码设置为0
	if (mkfifo(FILE_NAME, 0666) < 0){ //使用mkfifo创建命名管道文件
		perror("mkfifo");
		return 1;
	}
	int fd = open(FILE_NAME, O_RDONLY); //以读的方式打开命名管道文件
	if (fd < 0){
		perror("open");
		return 2;
	}
	char msg[128];
	while (1){
		msg[0] = '\0'; //每次读之前将msg清空
		//从命名管道当中读取信息
		ssize_t s = read(fd, msg, sizeof(msg)-1);
		if (s > 0){
			msg[s] = '\0'; //手动设置'\0'便于输出
			printf("client# %s\n", msg);
			if (fork() == 0){
				//child
				execlp(msg, msg, NULL); //进程程序替换
				exit(1);
			}
			waitpid(-1, NULL, 0); //等待子进程
		}
		else if (s == 0){
			printf("client quit!\n");
			break;
		}
		else{
			printf("read error!\n");
			break;
		}
	}
	close(fd); //通信完毕关闭命名管道文件
	return 0;
}

此时服务端接收到客户端的信息后便进行进程程序替换进而执行客户端发送过来的命令。

---

🍃2.3.8 用命名管道实现文件拷贝

生成一个txt文件然后进行拷贝

我们要做的就是让客户端将file.txt文件通过管道发送给服务端在服务端创建一个file-bat.txt文件并将从管道获取到的数据写入file-bat.txt文件当中至此便实现了file.txt文件的拷贝。

//server.cc
#include "comm.hpp"

int main()
{
	umask(0); //将文件默认掩码设置为0
	if (mkfifo(FILE_NAME, 0666) < 0){ //使用mkfifo创建命名管道文件
		perror("mkfifo");
		return 1;
	}
	int fd = open(FILE_NAME, O_RDONLY); //以读的方式打开命名管道文件
	if (fd < 0){
		perror("open");
		return 2;
	}
	//创建文件file-bat.txt并以写的方式打开该文件
	int fdout = open("file-bat.txt", O_CREAT | O_WRONLY, 0666);
	if (fdout < 0){
		perror("open");
		return 3;
	}
	char msg[128];
	while (1){
		msg[0] = '\0'; //每次读之前将msg清空
		//从命名管道当中读取信息
		ssize_t s = read(fd, msg, sizeof(msg)-1);
		if (s > 0){
			write(fdout, msg, s); //将读取到的信息写入到file-bat.txt文件当中
		}
		else if (s == 0){
			printf("client quit!\n");
			break;
		}
		else{
			printf("read error!\n");
			break;
		}
	}
	close(fd); //通信完毕关闭命名管道文件
	close(fdout); //数据写入完毕关闭file-bat.txt文件
	return 0;
}

而客户端需要做的就是以写的方式打开这个已经存在的命名管道文件再以读的方式打开file.txt文件之后需要做的就是将file.txt文件当中的数据读取出来并写入管道当中即可。

//client.cc
#include "comm.hpp"

int main()
{
	int fd = open(FILE_NAME, O_WRONLY); //以写的方式打开命名管道文件
	if (fd < 0){
		perror("open");
		return 1;
	}
	int fdin = open("file.txt", O_RDONLY); //以读的方式打开file.txt文件
	if (fdin < 0){
		perror("open");
		return 2;
	}
	char msg[128];
	while (1){
		//从file.txt文件当中读取数据
		ssize_t s = read(fdin, msg, sizeof(msg));
		if (s > 0){
			write(fd, msg, s); //将读取到的数据写入到命名管道当中
		}
		else if (s == 0){
			printf("read end of file!\n");
			 break;
		}
		else{
			printf("read error!\n");
			break;
		}
	}
	close(fd); //通信完毕关闭命名管道文件
	close(fdin); //数据读取完毕关闭file.txt文件
	return 0;
}

file.txt 和 file-bat.txt 文件当中的内容相同拷贝文件成功。

使用管道实现文件的拷贝有什么意义

因为这里是使用管道在本地进行的文件拷贝所以看似没什么意义但我们若是将这里的管道想象成“网络”将客户端想象成“shell”再将服务端想象成“centos服务器”。那我们此时实现的就是文件上传的功能若是将方向反过来那么实现的就是文件下载的功能。

---

🍃2.3.8 命名管道和匿名管道的区别

• 匿名管道由pipe函数创建并打开。
• 命名管道由mkfifo函数创建由open函数打开。
• FIFO命名管道与pipe匿名管道之间唯一的区别在于它们创建与打开的方式不同一旦这些工作完成之后它们具有相同的语义。

---

🍃2.3.9 命令行当中的管道

创建一个text.txt文件

我们可以利用管道“|”同时使用cat命令和grep命令进而实现文本过滤。

由于匿名管道只能用于有亲缘关系的进程之间的通信而命名管道可以用于两个毫不相关的进程之间的通信因此我们可以先看看命令行当中用管道“|”连接起来的各个进程之间是否具有亲缘关系。

下面通过管道“|”连接了三个进程通过ps命令查看这三个进程可以发现这三个进程的PPID是相同的也就是说它们是由同一个父进程创建的子进程。

而它们的父进程实际上就是命令行解释器这里为bash

也就是说由管道“|”连接起来的各个进程是有亲缘关系的它们之间互为兄弟进程。

现在我们已经知道了若是两个进程之间采用的是命名管道那么在磁盘上必须有一个对应的命名管道文件名而实际上我们在使用命令的时候并不存在类似的命名管道文件名因此命令行上的管道实际上是匿名管道。

---