Linux线程通信之共享映射区

IPC方法(InterProcess Communication)

• Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区中把数据读走，内核提供的这种机制称为进程间通信
  

• 在进程间完成数据传递需要借助os提供的特殊方法，如：文件、管道、信号、共享内存、消息队列、套接字、命名管道等。

• 现如今常用的进程间通信方式有：

1. 管道(使用最简单)
2. 信号(开销最小)
3. 共享映射区(无血缘关系)
4. 本地套接字(最稳定)

• Linux中七种符号类型

1. -：文件(占用磁盘存储)
2. d：目录(占用磁盘存储)
3. l：符号链接(软链接)(占用磁盘存储)
   伪文件：不占用磁盘存储
4. s：套接字
5. b：块设备
6. c：字符设备
7. p：管道

共享内存

共享存储映射

文件进程间通信

使用文件也可以完成IPC，理论依据是，fork后，父子进程共享文件描述符。也就是共享打开的文件
【练习】编程测试，父子进程共享打开的文件。借助文件进行进程间通信

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/wait.h>
int main()
{
	pid_t pid;
	int fd;
	char wbuf[512] = "hello world";
	char rbuf[512];
	pid = fork();
	fd = open("share.txt", O_RDWR | O_CREAT, 0644);
	if(pid < 0)
	{
		perror("fork error\n");
		return -1;
	}
	else if(pid > 0) //父进程向文件中写
	{
		if(fd < 0)
		{
			perror("open error\n");
			return -1;
		}
		write(fd, wbuf, sizeof(wbuf));
		wait(NULL);
	}
	else //子进程从文件中读
	{
		read(fd, rbuf, 512);
		printf("read %s\n", rbuf);	
	}
	return 0;
}

【运行结果】

【思考】无血缘关系的进程可以打开同一个文件进行通信吗？为什么？

mmap函数

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

【返回值】成功：返回创建的映射区首地址；失败：MAP_FAILED宏
【参数】
- addr：建立映射区的首地址，由Linux内核指定。使用时，直接传递NULL
- length：欲创建映射区的大小
- prot：映射区权限PROT_READ、PROT_WRITE、PROT_READ | PROT_WRITE
- flags：标志为参数(常用于设定更新物理区域、设置共享、创建匿名映射区)
	- MAP_SHARED：会将映射区所作的操作反映到物理设备(磁盘)上
	- MAP_PRIVATE：映射区所作的修改不会反映到物理设备
- fd：用来建立映射区的文件描述符
- offset：映射文件的偏移(4k的整数倍)

【练习】

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/mman.h>
int main()
{
	int fd;
	char *p; //接收返回映射区的地址
	int fileSize = 0;
	fd = open("test.txt", O_RDWR | O_CREAT, 0644); //打开文件
	fileSize = lseek(fd, 0, SEEK_END); //获取文件大小
	if(fileSize == -1)
	{
		perror("lseek error\n");
		return -1;
	}
	p = mmap(NULL, fileSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
	if(p == MAP_FAILED)
	{
		perror("mmap error\n");
		return -1;
	}
	strcpy(p, "hello world"); //将缓冲区内容修改为"hello world"，文件中也会做相应修改
	munmap(p ,fileSize); //释放映射区
	close(fd); //关闭文件
	
	return 0;
}

【运行结果】

【思考】

1. 可以在open的时候O_CREAT一个新文件来创建映射区吗？
   【可以】
2. 能否创建一个0字节的映射区？
   【不能，会报错】
3. 如果p++，munmap可否成功？（p的映射区首地址）
   【不能】，因为p++，那么p指向的就不是映射区的首地址，而munmap函数需要传入映射区首地址；即创建映射区的首地址和释放映射区的首地址要一致
4. 如果open时O_RDLONLY，mmap时PROT参数指定PROT_READ|PROT_WRITE会怎样？
   • 如果mmap参数为 MAP_SHARED,那么不能
   • 如果mmap参数为 MAP_PRIVATE,那么可以
     【创建映射区的权限要小于等于打开文件的权限，创建映射区的过程隐含着对文件进行一次读操作】
5. 如果文件偏移量为1000会怎样？
   【文件的偏移量必须是4k的整数倍，不然会出现无效参数】
   【因为是内核中的MMU帮你完成映射，MMU单位就是4K】
6. 如果不检测mmap的返回值，会怎样？
   【返回的p就是一个野指针】
7. 对p越界操作会怎样？
   【段错误】
8. mmap什么情况下会调用失败？
   【比如一个4字节的文件创建一个40字节的映射区，不行；如果一个40字节的文件创建一个4字节的映射区就可以】
9. 文件描述符先关闭，对mmap映射有没有影响？
   【没有影响】因为建立了映射区，操作文件的方式不再是通过fd(句柄)，而是通过映射区地址来操作，所以没有影响

【总结】

1. 创建映射区的过程中，隐含一次对映射文件的读操作
2. 当MAP_SHARED时，要求：映射区的权限 <= 文件打开的权限(对于映射区的保护)。而MAP_PRIVATE则无所谓，因为mmap中的权限是对内存的限制
3. 映射区的释放与文件关闭无关。只要映射成功，文件可以立即关闭
4. 特别注意，当映射文件大小为0时，不能创建映射区。所以：用于映射的文件必须要有实际大小！！mmap使用时会出现总线错误，通常是由于共享文件存储空间大小引起的
5. munmap传入的地址一定是mmap的返回地址。坚决杜绝指针++操作
6. 文件偏移量必须是4k的整数倍
7. mmap创建的映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作

mmap 父子进程通信

MAP_SHARED：（共享映射）父子进程共享映射区
MAP_PRIVATE：（私有映射）父子进程各自独占映射区
【练习】父子进程mmap通信(需要将mmap参数设置为：MAP_SHARED)

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

int var = 20;
int main()
{
	pid_t pid;
	int fd;
	int *p;
	fd = open("temp", O_RDWR | O_CREAT, 0644);
	if(fd < 0)
	{
		perror("open error\n");
		return -1;
	}
	unlink("temp");  //删除临时文件目录项，使它具备被释放的条件，当所有使用该文件的进程关闭之后，文件会被自动删除
	ftruncate(fd, 4); //创建文件大小为4字节
	p = (int *)mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
	if(p == MAP_FAILED)
	{
		perror("map error\n");
		return -1;
	}
	close(fd);
	pid = fork();
	if(pid < 0)
	{
		perror("fork error\n");
		return -1;
	}
	else if(pid > 0) //父进程向文件中写
	{
		*p = 100;
		var = 200;
		printf("In parent: var = %d, *p = %d\n", var, *p);
		wait(NULL);
	}
	else //子进程从文件中读
	{
		printf("In child: var = %d, *p = %d\n", var, *p);	
	}
	return 0;
}

【运行结果】

【结论】父子进程共享：1. 打开的文件 2.mmap建立的映射区(但必须使用MAP_SHARED)

匿名映射

• 通过使用我们发现，使用映射区来完成文件读写操作十分方便，父子进程间通信也比较容易。但缺陷是，每次创建映射区一定要依赖一个文件才可以实现。通常为了建设映射区要open一个temp文件，创建好了再unlink、close掉，比较麻烦。可以直接使用匿名映射来代替。其实Linux系统给我提供了创建匿名映射区的方法，无需依赖一个文件即可创建映射区。同样需要借助标志位参数flags来指定
• 使用 MAP_ANONYMOUS（或MAP_ANON）,如：

int *p = mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);

• 需要注意的是，MAP_ANONYMOUS（或MAP_ANON）这两个宏是Linux操作系统特有的宏，在类Unix系统中如无该宏定义，可使用如下两步来完成匿名映射区的建立

1. fd = open("dev/zero", O_RDWR);
2. p = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);

【可以在Linux下查看该字符设备文件】

【练习】创建匿名映射区

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

int var = 20;
int main()
{
	pid_t pid;
	int *p;

	p = (int *)mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANON, -1, 0);
	if(p == MAP_FAILED)
	{
		perror("map error\n");
		return -1;
	}
	pid = fork();
	if(pid < 0)
	{
		perror("fork error\n");
		return -1;
	}
	else if(pid > 0) //父进程向文件中写
	{
		*p = 100;
		var = 200;
		printf("In parent: var = %d, *p = %d\n", var, *p);
		wait(NULL);
	}
	else //子进程从文件中读
	{
		printf("In child: var = %d, *p = %d\n", var, *p);	
	}
	return 0;
}

非血缘关系进程间mmap通信

1. 一个进程往映射区中写入数据

// mmap_w.c
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/mman.h>
//定义一个结构体，写进程往该结构体中写入数据
struct student{
	int id;
	char name[10];
};
int main()
{
	char *p;
	struct student s = {10, "xiaoming"};
	int fd = open("share.txt", O_RDWR|O_CREAT, 0644);
	ftruncate(fd, sizeof(s)); //为文件"share.txt"创建4个字节大小的空间
	p = (char *)mmap(NULL, sizeof(s), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
	if(p == MAP_FAILED)
	{
		perror("map error\n");
		return -1;
	}
	close(fd);
	while(1)
	{
		memcpy(p, &s, sizeof(s));  //将结构体复制到p指向的内存映射区中
		s.id++;
		sleep(1);
	}
	munmap(p, sizeof(s));
	return 0;
}

2. 另一个进程从映射区中读出数据

// mmap_r.c
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/mman.h>

struct student{
	int id;
	char name[10];
};
int main()
{
	struct student *p; //用结构体指针来接收映射区的首地址
	struct student s;
	int fd = open("share.txt", O_RDONLY);
	p = (struct student *)mmap(NULL, sizeof(s), PROT_READ, MAP_SHARED, fd, 0);
	if(p == MAP_FAILED)
	{
		perror("map error\n");
		return -1;
	}
	close(fd);
	while(1)
	{
		printf("id = %d, name = %s\n", p->id, p->name);
		sleep(1);
	}
	munmap(p, sizeof(s));
	return 0;
}

【运行结果】可以开启多个读端对该共享映射区进行读操作