linux进程间通信快速入门【二】：共享内存编程(mmap、XSI、POSIX)

文章目录

• mmap内存共享映射
• XSI共享内存
• POSIX共享内存
• 参考

使用文件或管道进行进程间通信会有很多局限性，比如效率问题以及数据处理使用文件描述符而不如内存地址访问方便，于是多个进程以共享内存的方式进行通信就成了很自然要实现的IPC方案。
LInux给我们提供了三种共享内存的解决方案:

mmap内存共享映射。
XSI共享内存。
POSIX共享内存。

mmap内存共享映射

mmap可以将一个文件映射到内存中，在程序里就可以直接使用内存地址对文件内容进行访问，这可以让程序对文件访问更方便。
API：

#include <sys/mman.h>

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

int munmap(void *addr, size_t length);

Linux产生子进程的系统调用是fork，根据fork的语义以及其实现，我们知道新产生的进程在内存地址空间上跟父进程是完全一致的。所以Linux的mmap实现了一种可以在父子进程之间共享内存地址的方式，其使用方法是：
step1:父进程将flags参数设置MAP_SHARED方式通过mmap申请一段内存。内存可以映射某个具体文件，也可以不映射具体文件（fd置为-1，flag设置为MAP_ANONYMOUS）。
step2:父进程调用fork产生子进程。之后在父子进程内都可以访问到mmap所返回的地址，就可以共享内存了。
示例：并发100个进程写共享内存

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <sys/file.h>
#include <wait.h>
#include <sys/mman.h>

#define COUNT 100

int do_child(int *count)
{
	int interval;

	/* critical section */
	interval = *count;
	interval++;
	usleep(1);
	*count = interval;
	/* critical section */

	exit(0);
}

int main()
{
	pid_t pid;
	int count;
	int *shm_p;
	// 开辟一个int大小的共享内存 可读可写 Share changes Don't use a file.
	shm_p = (int *)mmap(NULL, sizeof(int), PROT_WRITE|PROT_READ, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
	if (MAP_FAILED == shm_p) {
		perror("mmap()");
		exit(1);
	}
	// 对该共享内存内容清零
	*shm_p = 0;
	// fork子进程，在子进程进行取数、++、置数操作
	for (count=0;count<COUNT;count++) {
		pid = fork();
		if (pid < 0) {
			perror("fork()");
			exit(1);
		}

		if (pid == 0) {
			do_child(shm_p);
		}
	}
	// 等待所有子进程生命周期结束
	for (count=0;count<COUNT;count++) {
		wait(NULL);
	}
	// 打印内容
	printf("shm_p: %d
", *shm_p);
	// 回收共享内存
	munmap(shm_p, sizeof(int));
	exit(0);
}

这个例子中，我们在子进程中为了延长临界区（critical section）处理的时间，使用了一个中间变量进行数值交换，并且还使用了usleep加强了一下racing的效果。结果如下：

[root@VM-90-225-centos /home/hanhan/SocketTest/LocalSocketDemo]# g++ ./racing_mmap.cpp -o racing_mmap
[root@VM-90-225-centos /home/hanhan/SocketTest/LocalSocketDemo]# ./racing_mmap 
shm_p: 37
[root@VM-90-225-centos /home/hanhan/SocketTest/LocalSocketDemo]# ./racing_mmap 
shm_p: 44
[root@VM-90-225-centos /home/hanhan/SocketTest/LocalSocketDemo]# ./racing_mmap 
shm_p: 41

这段共享内存的使用是有竞争条件存在的，从文件锁的例子我们知道，进程间通信绝不仅仅是通信这么简单，还需要处理类似这样的临界区代码。在这里，我们也可以使用文件锁进行处理，但是共享内存使用文件锁未免显得太不协调了。除了不方便以及效率低下以外，文件锁还不能够进行更高级的进程控制。所以，我们在此需要引入更高级的进程同步控制原语来实现相关功能，这就是信号量（semaphore）的作用。这里信号量不是重点，将在后面的系列文章中进行探讨。

应该注意，mmap方式的共享内存只能在通过fork产生的父子进程间通信，因为除此之外的其它进程无法得到共享内存段的地址。
接下来再看看mmap开辟的内存位于哪里吧：

/*
 * @Author: your name
 * @Date: 2022-03-17 19:00:57
 * @LastEditTime: 2022-03-17 19:00:58
 * @LastEditors: Please set LastEditors
 * @Description: 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
 * @FilePath: /SocketTest/LocalSocketDemo/mmap.cpp
 */
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <sys/file.h>
#include <wait.h>
#include <sys/mman.h>

#define COUNT 100
#define MEMSIZE 1024*1024*1023*1

int main()
{
	pid_t pid;
	int count;
	void *shm_p;

	shm_p = mmap(NULL, MEMSIZE, PROT_WRITE|PROT_READ, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
	if (MAP_FAILED == shm_p) {
		perror("mmap()");
		exit(1);
	}

	bzero(shm_p, MEMSIZE);

	sleep(3000);

	munmap(shm_p, MEMSIZE);
	exit(0);
}

结果如下：

[root@VM-90-225-centos /home/hanhan/SocketTest/LocalSocketDemo]# g++ ./mmap.cpp -o mmap
[root@VM-90-225-centos /home/hanhan/SocketTest/LocalSocketDemo]# free -g
              total        used        free      shared  buff/cache   available
Mem:             15           8           3           0           2           6
Swap:             0           0           0
[root@VM-90-225-centos /home/hanhan/SocketTest/LocalSocketDemo]# ./mmap &
[1] 23994
[root@VM-90-225-centos /home/hanhan/SocketTest/LocalSocketDemo]# free -g
              total        used        free      shared  buff/cache   available
Mem:             15           8           2           1           3           5
Swap:             0           0           0

我们开辟了一个G内存，Centos的环境中mmap的共享内存会记录到buff/cache中。

XSI共享内存

为了满足多个无关进程共享内存的需求，Linux提供了更具通用性的共享内存手段，XSI共享内存就是这样一种实现。
XSI是X/Open组织对UNIX定义的一套接口标准(X/Open System Interface)。由于UNIX系统的历史悠久，在不同时间点的不同厂商和标准化组织定义过一些列标准，而目前比较通用的标准实际上是POSIX。我们还会经常遇到的标准还包括SUS（Single UNIX Specification）标准，它们大概的关系是，SUS是POSIX标准的超集，定义了部分额外附加的接口，这些接口扩展了基本的POSIX规范。相应的系统接口全集被称为XSI标准，除此之外XSI还定义了实现必须支持的POSIX的哪些可选部分才能认为是遵循XSI的。它们包括文件同步，存储映射文件，存储保护及线程接口。只有遵循XSI标准的实现才能称为UNIX操作系统。
XSI共享内存在Linux底层的实现实际上跟mmap没有什么本质不同，只是在使用方法上有所区别。其使用的相关方法为：

#include <sys/ipc.h>
#include <sys/shm.h>

int shmget(key_t key, size_t size, int shmflg);
   
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
   
#include <sys/types.h>
#include <sys/shm.h>

void *shmat(int shmid, const void *shmaddr, int shmflg);

int shmdt(const void *shmaddr);

在一个操作系统内，如何让两个不相关（没有父子关系）的进程可以共享一个内存段？系统中是否有现成的解决方案呢？
当然有，就是文件。我们知道，文件的设计就可以让无关的进程可以进行数据交换。文件采用路径和文件名作为系统全局的一个标识符，但是每个进程打开这个文件之后，在进程内部都有一个“文件描述符”去指向文件。此时进程通过fork打开的子进程可以继承父进程的文件描述符，但是无关进程依然可以通过系统全局的文件名用open系统调用再次打开同一个文件，以便进行进程间通信。
实际上对于XSI的共享内存，其key的作用就类似文件的文件名，shmget返回的int类型的shmid就类似文件描述符，注意只是“类似”，而并非是同样的实现。这意味着，我们在进程中不能用select、poll、epoll这样的方法去控制一个XSI共享内存，因为它并不是“文件描述符”。对于一个XSI的共享内存，其key是系统全局唯一的，这就方便其他进程使用同样的key，打开同样一段共享内存，以便进行进程间通信。而使用fork产生的子进程，则可以直接通过shmid访问到相关共享内存段。这就是key的本质：系统中对XSI共享内存的全局唯一表示符。
那么key是如何产生的呢？

#include <sys/types.h>
#include <sys/ipc.h>

key_t ftok(const char *pathname, int proj_id);

一个key是通过ftok函数，使用一个pathname和一个proj_jd产生的。就是说，在一个可能会使用共享内存的项目组中，大家可以约定一个文件名和一个项目的proj_id，来在同一个系统中确定一段共享内存的key。ftok并不会去创建文件，所以必须指定一个存在并且进程可以访问的pathname路径。这里还要指出的一点是，ftok实际上并不是根据文件的文件路径和文件名（pathname）产生key的，在实现上，它使用的是指定文件的inode编号和文件所在设备的设备编号。所以，不要以为你是用了不同的文件名就一定会得到不同的key，因为不同的文件名是可以指向相同inode编号的文件的（硬连接）。也不要认为你是用了相同的文件名就一定可以得到相同的key，在一个系统上，同一个文件名会被删除重建的几率是很大的，这种行为很有可能导致文件的inode变化。所以一个ftok的执行会隐含stat系统调用也就不难理解了。
key作为全局唯一标识不仅仅体现在XSI的共享内存中，XSI标准的其他进程间通信机制（信号量数组和消息队列）也使用这一命名方式。
示例：多进程并发写，会有竞争

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <sys/file.h>
#include <wait.h>
#include <sys/mman.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>

#define COUNT 100
#define PATHNAME "/etc/passwd"

int do_child(int proj_id)
{
	int interval;
	int *shm_p, shm_id;
	key_t shm_key;
	/* 使用ftok产生shmkey */
	if ((shm_key = ftok(PATHNAME, proj_id)) == -1) {
		perror("ftok()");
		exit(1);
	}
	/* 在子进程中使用shmget取到已经在父进程中创建好的共享内存id，注意shmget的第三个参数的使用。 */
	shm_id = shmget(shm_key, sizeof(int), 0);
	if (shm_id < 0) {
		perror("shmget()");
		exit(1);
	}
	
	/* 使用shmat将相关共享内存段映射到本进程的内存地址。 */

	shm_p = (int *)shmat(shm_id, NULL, 0);
	if ((void *)shm_p == (void *)-1) {
		perror("shmat()");
		exit(1);
	}

	/* critical section */
	interval = *shm_p;
	interval++;
	usleep(1);
	*shm_p = interval;
	/* critical section */

	/* 使用shmdt解除本进程内对共享内存的地址映射，本操作不会删除共享内存。 */
	if (shmdt(shm_p) < 0) {
		perror("shmdt()");
		exit(1);
	}

	exit(0);
}

int main()
{
	pid_t pid;
	int count;
	int *shm_p;
	int shm_id, proj_id;
	key_t shm_key;

	proj_id = 1234;
	
	/* 使用约定好的文件路径和proj_id产生shm_key。 */
	if ((shm_key = ftok(PATHNAME, proj_id)) == -1) {
		perror("ftok()");
		exit(1);
	}

	/* 使用shm_key创建一个共享内存，如果系统中已经存在此共享内存则报错退出，创建出来的共享内存权限为0600。 */
	shm_id = shmget(shm_key, sizeof(int), IPC_CREAT|IPC_EXCL|0600);
	if (shm_id < 0) {
		perror("shmget()");
		exit(1);
	}

	/* 将创建好的共享内存映射进父进程的地址以便访问。 */
	shm_p = (int *)shmat(shm_id, NULL, 0);
	if ((void *)shm_p == (void *)-1) {
		perror("shmat()");
		exit(1);
	}

	/* 共享内存赋值为0。 */
	*shm_p = 0;

	/*  打开100个子进程并发读写共享内存。 */
	for (count=0;count<COUNT;count++) {
		pid = fork();
		if (pid < 0) {
			perror("fork()");
			exit(1);
		}

		if (pid == 0) {
			do_child(proj_id);
		}
	}
	
	/* 等待所有子进程执行完毕。 */
	for (count=0;count<COUNT;count++) {
		wait(NULL);
	}

	/* 显示当前共享内存的值。 */
	printf("shm_p: %d
", *shm_p);


	/* 解除共享内存地质映射。 */
	if (shmdt(shm_p) < 0) {
		perror("shmdt()");
		exit(1);
	}

	/* 删除共享内存。 */
	if (shmctl(shm_id, IPC_RMID, NULL) < 0) {
		perror("shmctl()");
		exit(1);
	}

	exit(0);
}

XSI共享内存跟mmap在实现上并没有本质区别。而之所以引入key和shmid的概念，也主要是为了在非父子关系的进程之间可以共享内存。根据上面的例子可以看到，使用shmget可以根据key创建共享内存，并返回一个shmid。它的第二个参数size用来指定共享内存段的长度，第三个参数指定创建的标志，可以支持的标志为：IPC_CREAT、IPC_EXCL。从Linux 2.6之后，还引入了支持大页的共享内存，标志为：SHM_HUGETLB、SHM_HUGE_2MB等参数。shmget除了可以创建一个新的共享内存以外，还可以访问一个已经存在的共享内存，此时可以将shmflg置为0，不加任何标识打开。

当获得shmid之后，就可以使用shmat来进行地址映射。shmat之后，通过访问返回的当前进程的虚拟地址就可以访问到共享内存段了。当然，在使用之后要记得使用shmdt解除映射，否则对于长期运行的程序可能造成虚拟内存地址泄漏，导致没有可用地址可用。shmdt并不能删除共享内存段，而只是解除共享内存和进程虚拟地址的映射，只要shmid对应的共享内存还存在，就仍然可以继续使用shmat映射使用。想要删除一个共享内存需要使用shmctl的IPC_RMID指令处理。也可以在命令行中使用ipcrm删除指定的共享内存id或key。
注意点：

共享内存由于其特性，与进程中的其他内存段在使用习惯上有些不同。一般进程对栈空间分配可以自动回收，而堆空间通过malloc申请，free回收。这些内存在回收之后就可以认为是不存在了。但是共享内存不同，用shmdt之后，实际上其占用的内存还在，并仍然可以使用shmat映射使用。如果不是用shmctl或ipcrm命令删除的话，那么它将一直保留直到系统被关闭。当然，文件如果不删除，下次重启依旧还在，因为它放在硬盘上，而共享内存下次重启就没了，因为它毕竟还是内存。

跟mmap的共享内存一样，XSI的共享内存在free现实中也会占用shared和buff/cache的消耗。实际上，在内核底层实现上，两种内存共享都是使用的tmpfs方式实现的，所以它们实际上的内存使用都是一致的。

POSIX共享内存

XSI共享内存是历史比较悠久，也比较经典的共享内存手段。它几乎代表了共享内存的默认定义，当我们说有共享内存的时候，一般意味着使用了XSI的共享内存。但是这种共享内存也存在一切缺点，最受病垢的地方莫过于他提供的key＋projid的命名方式不够UNIX，没有遵循一切皆文件的设计理念。
如果共享内存可以用文件描述符的方式提供给程序访问，毫无疑问可以在Linux上跟select、poll、epoll这样的IO异步事件驱动机制配合使用，做到一些更高级的功能。于是，遵循一切皆文件理念的POSIX标准的进程间通信机制应运而生。

POSIX共享内存实际上毫无新意，它本质上就是mmap对文件的共享方式映射，只不过映射的是tmpfs文件系统上的文件。

什么是tmpfs？Linux提供一种“临时”文件系统叫做tmpfs，它可以将内存的一部分空间拿来当做文件系统使用，使内存空间可以当做目录文件来用。Linux提供的POSIX共享内存，实际上就是在/dev/shm下创建一个文件，并将其mmap之后映射其内存地址即可。我们通过它给定的一套参数就能猜到它的主要函数shm_open无非就是open系统调用的一个封装。大家可以通过man shm_overview来查看相关操作的方法。
POSIX共享内存的使用相关方法如下：

#include <sys/mman.h>
#include <sys/stat.h>        /* For mode constants */
#include <fcntl.h>           /* For O_* constants */

int shm_open(const char *name, int oflag, mode_t mode);

int shm_unlink(const char *name);

使用shm_open可以创建或者访问一个已经创建的共享内存。上面说过，实际上POSIX共享内存就是在/dev/shm目录中的的一个tmpfs格式的文件，所以shm_open无非就是open系统调用的封装，所以起函数使用的参数几乎一样。其返回的也是一个标准的我呢间描述符。

shm_unlink也一样是unlink调用的封装，用来删除文件名和文件的映射关系。在这就能看出POSIX共享内存和XSI的区别了，一个是使用文件名作为全局标识，另一个是使用key。

映射共享内存地址使用mmap，解除映射使用munmap。使用ftruncate设置共享内存大小，实际上就是对tmpfs的文件进行指定长度的截断。使用fchmod、fchown、fstat等系统调用修改和查看相关共享内存的属性。close调用关闭共享内存的描述符。实际上，这都是标准的文件操作。
下面看一下具体示例：
示例：多进程读写，有竞争

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <sys/file.h>
#include <wait.h>
#include <sys/mman.h>

#define COUNT 100
#define SHMPATH "shm"

int do_child(char * shmpath)
{
	int interval, shmfd, ret;
	int *shm_p;
	/* 使用shm_open访问一个已经创建的POSIX共享内存 */
	shmfd = shm_open(shmpath, O_RDWR, 0600);
	if (shmfd < 0) {
		perror("shm_open()");
		exit(1);
	}

	/* 使用mmap将对应的tmpfs文件映射到本进程内存 */
	shm_p = (int *)mmap(NULL, sizeof(int), PROT_WRITE|PROT_READ, MAP_SHARED, shmfd, 0);
	if (MAP_FAILED == shm_p) {
		perror("mmap()");
		exit(1);
	}
	/* critical section */
	interval = *shm_p;
	interval++;
	usleep(1);
	*shm_p = interval;
	/* critical section */
	munmap(shm_p, sizeof(int));
	close(shmfd);

	exit(0);
}

int main()
{
	pid_t pid;
	int count, shmfd, ret;
	int *shm_p;

	/* 创建一个POSIX共享内存 */
	shmfd = shm_open(SHMPATH, O_RDWR|O_CREAT|O_TRUNC, 0600);
	if (shmfd < 0) {
		perror("shm_open()");
		exit(1);
	}

	/* 使用ftruncate设置共享内存段大小 */
	ret = ftruncate(shmfd, sizeof(int));
	if (ret < 0) {
		perror("ftruncate()");
		exit(1);
	}

	/* 使用mmap将对应的tmpfs文件映射到本进程内存 */
	shm_p = (int *)mmap(NULL, sizeof(int), PROT_WRITE|PROT_READ, MAP_SHARED, shmfd, 0);
	if (MAP_FAILED == shm_p) {
		perror("mmap()");
		exit(1);
	}

	*shm_p = 0;

	for (count=0;count<COUNT;count++) {
		pid = fork();
		if (pid < 0) {
			perror("fork()");
			exit(1);
		}

		if (pid == 0) {
			do_child(SHMPATH);
		}
	}

	for (count=0;count<COUNT;count++) {
		wait(NULL);
	}

	printf("shm_p: %d
", *shm_p);
	munmap(shm_p, sizeof(int));
	close(shmfd);
	//sleep(3000);
	shm_unlink(SHMPATH);
	exit(0);
}


[root@VM-90-225-centos /home/hanhan/SocketTest/LocalSocketDemo]# g++ ./racing_posix_shm.cpp -o racing_posix_shm
./racing_posix_shm.cpp: In function ‘int main()’:
./racing_posix_shm.cpp:80:20: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
    do_child(SHMPATH);
                    ^
/tmp/ccduro4X.o: In function `do_child(char*)':
racing_posix_shm.cpp:(.text+0x1e): undefined reference to `shm_open'
/tmp/ccduro4X.o: In function `main':
racing_posix_shm.cpp:(.text+0xe0): undefined reference to `shm_open'
racing_posix_shm.cpp:(.text+0x215): undefined reference to `shm_unlink'
collect2: error: ld returned 1 exit status

编译执行这个程序需要指定一个额外rt的库，可以使用如下命令进行编译：

g++ ./racing_posix_shm.cpp -lrt -o racing_posix_shm

编译好可以看到，正好是在编译好之后，dev/shm文件路径被创建

root@VM-90-225-centos /dev]
...
drwxrwxrwt  2 root root          40 Mar 18 15:17 shm
...

解释：

shm_open的SHMPATH参数是一个路径，这个路径默认放在系统的/dev/shm目录下。这是shm_open已经封装好的，保证了文件一定会使用tmpfs。
shm_open实际上就是open系统调用的封装。我们当然完全可以使用open的方式模拟这个方法。
使用ftruncate方法来设置“共享内存”的大小。其实就是更改文件的长度。
要以共享方式做mmap映射，并且指定文件描述符为shmfd。
shm_unlink实际上就是unlink系统调用的封装。如果不做unlink操作，那么文件会一直存在于/dev/shm目录下，以供其它进程使用。
关闭共享内存描述符直接使用close。

其本质上就是个tmpfs文件。那么从这个角度说，mmap匿名共享内存、XSI共享内存和POSIX共享内存在内核实现本质上其实都是tmpfs。如果我们去查看POSIX共享内存的free空间占用的话，结果将跟mmap和XSI共享内存一样占用shared和buff/cache.

参考

https://zorrozou.github.io/docs/books/linuxjin-cheng-jian-tong-4fe1-gong-xiang-nei-cun.html