内存映射mmap：高效读写数据的利器

内存映射是一种操作系统提供的技术，将磁盘上的文件映射到进程的地址空间中，使得文件可以像访问内存一样被读写。通过内存映射，可以避免频繁的磁盘IO操作，从而提升读写性能。

内存映射文件，是由一个文件到一块内存的映射。Win32提供了允许应用程序把文件映射到一个进程的函数 (CreateFileMapping)。内存映射文件与虚拟内存有些类似，通过内存映射文件可以保留一个地址空间的区域，同时将物理存储器提交给此区域，内存文件映射的物理存储器来自一个已经存在于磁盘上的文件，而且在对该文件进行操作之前必须首先对文件进行映射。使用内存映射文件处理存储于磁盘上的文件时，将不必再对文件执行I/O操作，使得内存映射文件在处理大数据量的文件时能起到相当重要的作用。

一、概念

内存映射是通过将磁盘文件映射到进程的地址空间中来实现的。在这种方式下，操作系统会将文件的某个区域映射到进程的虚拟地址空间中，从而使得程序可以直接访问这个区域的数据。

在 Linux 系统中，内存映射是通过调用 mmap() 函数来实现的。这个函数的原型如下：

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
/*
addr：指定映射的起始地址。如果为 NULL，则由操作系统自动选择一个地址。
length：指定映射的长度。
prot：指定映射区域的保护方式。可以是以下几种值的组合：
    PROT_READ：可读。
    PROT_WRITE：可写。
    PROT_EXEC：可执行。
flags：指定映射区域的标志。可以是以下几种值的组合：
    MAP_SHARED：与其他进程共享映射区域。
    MAP_PRIVATE：不与其他进程共享映射区域。
    MAP_FIXED：指定映射区域的起始地址。如果指定了这个标志，则 addr 参数必须为非 NULL。
    MAP_ANONYMOUS：不映射任何文件，而是映射一段匿名的内存区域。
fd：指定要映射的文件描述符。
offset：指定要映射的文件的偏移量。
*/

下面代码的作用是读取一个文件的内容，并将其输出到屏幕上。然后，它将文件的内容修改为 "Hello, world!"，并将修改后的内容写回到磁盘中。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
 
int main(int argc, char *argv[]) {
    int fd;
    char *addr;
    struct stat sb;
 
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <file>\n", argv[0]);
        exit(EXIT_FAILURE);
    }
 
    fd = open(argv[1], O_RDWR);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }
 
    if (fstat(fd, &sb) == -1) {
        perror("fstat");
        exit(EXIT_FAILURE);
    }
 
    addr = mmap(NULL, sb.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (addr == MAP_FAILED) {
        perror("mmap");
        exit(EXIT_FAILURE);
    }
 
    printf("The file content is: %s\n", addr);
 
    strcpy(addr, "Hello, world!");
 
    if (msync(addr, sb.st_size, MS_SYNC) == -1) {
        perror("msync");
        exit(EXIT_FAILURE);
    }
 
    if (munmap(addr, sb.st_size) == -1) {
        perror("munmap");
        exit(EXIT_FAILURE);
    }
 
    close(fd);
 
    return 0;
}

与 Direct IO 的不同

内存映射和 Direct IO 都是用来提高文件读写性能的技术，但它们之间有一些不同。

首先，内存映射是将文件映射到进程的地址空间中，而 Direct IO 是直接使用文件描述符进行读写操作。因此，内存映射可以充分利用虚拟内存系统的优势，而 Direct IO 则可以避免缓存的影响。

其次，内存映射可以实现文件的共享访问，而 Direct IO 则不行。这是因为 Direct IO 会绕过文件系统缓存，而文件系统缓存是用来实现文件共享访问的。

最后在内存映射中，修改过的数据会被缓存在内存中，并不会立即写回到磁盘中。如果需要将数据写回到磁盘中，可以使用 msync() 函数或者 munmap() 函数来实现。而 Direct IO 是可以直接将数据写入磁盘的。

1.1mmap是什么

mmap是一种内存映射文件的方法，即将一个文件或者其它对象映射到进程的地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系。实现这样的映射关系后，进程就可以采用指针的方式读写操作这一段内存，而系统会自动回写脏页面到对应的文件磁盘上，即完成了对文件的操作而不必再调用read,write等系统调用函数。相反，内核空间对这段区域的修改也直接反映用户空间，从而可以实现不同进程间的文件共享。

如下图所示：

由上图可以看出，进程的虚拟地址空间，由多个虚拟内存区域构成。虚拟内存区域是进程的虚拟地址空间中的一个同质区间，即具有同样特性的连续地址范围。上图中所示的text数据段（代码段）、初始数据段、BSS数据段、堆、栈和内存映射，都是一个独立的虚拟内存区域。

而为内存映射服务的地址空间处在堆栈之间的空余部分。linux内核使用vm_area_struct结构来表示一个独立的虚拟内存区域，由于每个不同质的虚拟内存区域功能和内部机制都不同，因此一个进程使用多个vm_area_struct结构来分别表示不同类型的虚拟内存区域。各个vm_area_struct结构使用链表或者树形结构链接，方便进程快速访问，如下图所示：

vm_area_struct结构中包含区域起始和终止地址以及其他相关信息，同时也包含一个vm_ops指针，其内部可引出所有针对这个区域可以使用的系统调用函数。这样，进程对某一虚拟内存区域的任何操作需要用要的信息，都可以从vm_area_struct中获得。mmap函数就是要创建一个新的vm_area_struct结构，并将其与文件的物理磁盘地址相连。

1.2mmap内存映射原理

mmap内存映射的实现过程，总的来说可以分为三个阶段：

（一）进程启动映射过程，并在虚拟地址空间中为映射创建虚拟映射区域

• 1、进程在用户空间调用库函数mmap，原型：void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);

• 2、在当前进程的虚拟地址空间中，寻找一段空闲的满足要求的连续的虚拟地址

• 3、为此虚拟区分配一个vm_area_struct结构，接着对这个结构的各个域进行了初始化

• 4、将新建的虚拟区结构（vm_area_struct）插入进程的虚拟地址区域链表或树中

（二）调用内核空间的系统调用函数mmap（不同于用户空间函数），实现文件物理地址和进程虚拟地址的一一映射关系

• 5、为映射分配了新的虚拟地址区域后，通过待映射的文件指针，在文件描述符表中找到对应的文件描述符，通过文件描述符，链接到内核“已打开文件集”中该文件的文件结构体（struct file），每个文件结构体维护着和这个已打开文件相关各项信息。

• 6、通过该文件的文件结构体，链接到file_operations模块，调用内核函数mmap，其原型为：int mmap(struct file *filp, struct vm_area_struct *vma)，不同于用户空间库函数。

• 7、内核mmap函数通过虚拟文件系统inode模块定位到文件磁盘物理地址。

• 8、通过remap_pfn_range函数建立页表，即实现了文件地址和虚拟地址区域的映射关系。此时，这片虚拟地址并没有任何数据关联到主存中。

（三）进程发起对这片映射空间的访问，引发缺页异常，实现文件内容到物理内存（主存）的拷贝
注：前两个阶段仅在于创建虚拟区间并完成地址映射，但是并没有将任何文件数据的拷贝至主存。真正的文件读取是当进程发起读或写操作时。

1. 9、进程的读或写操作访问虚拟地址空间这一段映射地址，通过查询页表，发现这一段地址并不在物理页面上。因为目前只建立了地址映射，真正的硬盘数据还没有拷贝到内存中，因此引发缺页异常。

2. 10、缺页异常进行一系列判断，确定无非法操作后，内核发起请求调页过程。

3. 11、调页过程先在交换缓存空间（swap cache）中寻找需要访问的内存页，如果没有则调用nopage函数把所缺的页从磁盘装入到主存中。

4. 12、之后进程即可对这片主存进行读或者写的操作，如果写操作改变了其内容，一定时间后系统会自动回写脏页面到对应磁盘地址，也即完成了写入到文件的过程。
   注：修改过的脏页面并不会立即更新回文件中，而是有一段时间的延迟，可以调用msync()来强制同步, 这样所写的内容就能立即保存到文件里了。

1.3mmap和常规文件操作的区别

常规文件操作需要从磁盘到页缓存(处于内核空间，不能被用户进程直接寻址)，再到用户主存的两次数据拷贝。而mmap操控文件，只需要从磁盘到用户主存的一次数据拷贝过程（创建新的虚拟内存区域，建议文件磁盘地址和虚拟内存区域映射，一次拷贝）。

我们首先简单的回顾一下常规文件系统操作（调用read/fread等类函数）中，函数的调用过程：

• 1、进程发起读文件请求。

• 2、内核通过查找进程文件符表，定位到内核已打开文件集上的文件信息，从而找到此文件的inode。

• 3、inode在address_space上查找要请求的文件页是否已经缓存在页缓存中。如果存在，则直接返回这片文件页的内容。

• 4、如果不存在，则通过inode定位到文件磁盘地址，将数据从磁盘复制到页缓存。之后再次发起读页面过程，进而将页缓存中的数据发给用户进程。

总结来说，常规文件操作为了提高读写效率和保护磁盘，使用了页缓存机制。这样造成读文件时需要先将文件页从磁盘拷贝到页缓存中，由于页缓存处在内核空间，不能被用户进程直接寻址，所以还需要将页缓存中数据页再次拷贝到内存对应的用户空间中。这样，通过了两次数据拷贝过程，才能完成进程对文件内容的获取任务。写操作也是一样，待写入的buffer在内核空间不能直接访问，必须要先拷贝至内核空间对应的主存，再写回磁盘中（延迟写回），也是需要两次数据拷贝。

而使用mmap操作文件中，创建新的虚拟内存区域和建立文件磁盘地址和虚拟内存区域映射这两步，没有任何文件拷贝操作。而之后访问数据时发现内存中并无数据而发起的缺页异常过程，可以通过已经建立好的映射关系，只使用一次数据拷贝，就从磁盘中将数据传入内存的用户空间中，供进程使用。

总而言之，常规文件操作需要从磁盘到页缓存再到用户主存的两次数据拷贝。而mmap操控文件，只需要从磁盘到用户主存的一次数据拷贝过程。说白了，mmap的关键点是实现了用户空间和内核空间的数据直接交互而省去了空间不同数据不通的繁琐过程。因此mmap效率更高。

1.4mmap的优点

mmap系统调用使得进程之间通过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后，进程可以像访问普通内存一样对文件进行访问，不必再调用read()，write（）等操作。mmap并不分配空间, 只是将文件映射到调用进程的地址空间里, 然后你就可以用memcpy等操作写文件, 而不用write()了.写完后用msync()同步一下, 你所写的内容就保存到文件里了. 不过这种方式没办法增加文件的长度, 因为要映射的长度在调用mmap()的时候就决定了.

mmap优点共有一下几点：

1、对文件的读取操作跨过了页缓存，减少了数据的拷贝次数，用内存读写取代I/O读写，提高了文件读取效率。

2、实现了用户空间和内核空间的高效交互方式。两空间的各自修改操作可以直接反映在映射的区域内，从而被对方空间及时捕捉。

3、提供进程间共享内存及相互通信的方式。不管是父子进程还是无亲缘关系的进程，都可以将自身用户空间映射到同一个文件或匿名映射到同一片区域。从而通过各自对映射区域的改动，达到进程间通信和进程间共享的目的。
同时，如果进程A和进程B都映射了区域C，当A第一次读取C时通过缺页从磁盘复制文件页到内存中；但当B再读C的相同页面时，虽然也会产生缺页异常，但是不再需要从磁盘中复制文件过来，而可直接使用已经保存在内存中的文件数据。

4、可用于实现高效的大规模数据传输。内存空间不足，是制约大数据操作的一个方面，解决方案往往是借助硬盘空间协助操作，补充内存的不足。但是进一步会造成大量的文件I/O操作，极大影响效率。这个问题可以通过mmap映射很好的解决。换句话说，但凡是需要用磁盘空间代替内存的时候，mmap都可以发挥其功效。

1.5mmap相关函数

函数原型

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

返回说明

成功执行时，mmap()返回被映射区的指针。失败时，mmap()返回MAP_FAILED[其值为(void *)-1]，error被设为以下的某个值：

• EACCES：访问出错

• EAGAIN：文件已被锁定，或者太多的内存已被锁定

• EBADF：fd不是有效的文件描述词

• EINVAL：一个或者多个参数无效

• ENFILE：已达到系统对打开文件的限制

• ENODEV：指定文件所在的文件系统不支持内存映射

• ENOMEM：内存不足，或者进程已超出最大内存映射数量

• EPERM：权能不足，操作不允许

• ETXTBSY：已写的方式打开文件，同时指定MAP_DENYWRITE标志

• SIGSEGV：试着向只读区写入

• SIGBUS：试着访问不属于进程的内存区

参数

• start：映射区的开始地址

• length：映射区的长度

• prot：期望的内存保护标志，不能与文件的打开模式冲突。是以下的某个值，可以通过or运算合理地组合在一起

• PROT_EXEC：页内容可以被执行

• PROT_READ：页内容可以被读取

• PROT_WRITE：页可以被写入

• PROT_NONE：页不可访问

• flags：指定映射对象的类型，映射选项和映射页是否可以共享。它的值可以是一个或者多个以下位的组合体

• MAP_FIXED //使用指定的映射起始地址，如果由start和len参数指定的内存区重叠于现存的映射空间，重叠部分将会被丢弃。如果指定的起始地址不可用，操作将会失败。并且起始地址必须落在页的边界上。

• MAP_SHARED //与其它所有映射这个对象的进程共享映射空间。对共享区的写入，相当于输出到文件。直到msync()或者munmap()被调用，文件实际上不会被更新。

• MAP_PRIVATE //建立一个写入时拷贝的私有映射。内存区域的写入不会影响到原文件。这个标志和以上标志是互斥的，只能使用其中一个。

• MAP_DENYWRITE //这个标志被忽略。

• MAP_EXECUTABLE //同上

• MAP_NORESERVE //不要为这个映射保留交换空间。当交换空间被保留，对映射区修改的可能会得到保证。当交换空间不被保留，同时内存不足，对映射区的修改会引起段违例信号。

• MAP_LOCKED //锁定映射区的页面，从而防止页面被交换出内存。

• MAP_GROWSDOWN //用于堆栈，告诉内核VM系统，映射区可以向下扩展。

• MAP_ANONYMOUS //匿名映射，映射区不与任何文件关联。

• MAP_ANON //MAP_ANONYMOUS的别称，不再被使用。

• MAP_FILE //兼容标志，被忽略。

• MAP_32BIT //将映射区放在进程地址空间的低2GB，MAP_FIXED指定时会被忽略。当前这个标志只在x86-64平台上得到支持。

• MAP_POPULATE //为文件映射通过预读的方式准备好页表。随后对映射区的访问不会被页违例阻塞。

• MAP_NONBLOCK //仅和MAP_POPULATE一起使用时才有意义。不执行预读，只为已存在于内存中的页面建立页表入口。

• fd：有效的文件描述词。如果MAP_ANONYMOUS被设定，为了兼容问题，其值应为-1

• offset：被映射对象内容的起点

相关函数

int munmap( void * addr, size_t len )

成功执行时，munmap()返回0。失败时，munmap返回-1，error返回标志和mmap一致；该调用在进程地址空间中解除一个映射关系，addr是调用mmap()时返回的地址，len是映射区的大小；当映射关系解除后，对原来映射地址的访问将导致段错误发生。

int msync( void *addr, size_t len, int flags )

一般说来，进程在映射空间的对共享内容的改变并不直接写回到磁盘文件中，往往在调用munmap（）后才执行该操作。可以通过调用msync()实现磁盘上文件内容与共享内存区的内容一致。

int msync( void *addr, size_t len, int flags )

一般说来，进程在映射空间的对共享内容的改变并不直接写回到磁盘文件中，往往在调用munmap（）后才执行该操作，可以通过调用msync()实现磁盘上文件内容与共享内存区的内容一致。

为什么mmap效率高于read/write？

常规文件操作为了提高读写效率和保护磁盘，使用了页缓存机制。这样造成读文件时需要先将文件页从磁盘拷贝到页缓存中，由于页缓存处在内核空间，不能被用户进程直接寻址，所以还需要将页缓存中数据页再次拷贝到内存对应的用户空间中。这样，通过了两次数据拷贝过程，才能完成进程对文件内容的获取任务。写操作也是一样，待写入的buffer在内核空间不能直接访问，必须要先拷贝至内核空间对应的主存，再写回磁盘中（延迟写回），也是需要两次数据拷贝。

而使用mmap操作文件中，创建新的虚拟内存区域和建立文件磁盘地址和虚拟内存区域映射这两步，没有任何文件拷贝操作。而之后访问数据时发现内存中并无数据而发起的缺页异常过程，可以通过已经建立好的映射关系，只使用一次数据拷贝，就从磁盘中将数据传入内存的用户空间中，供进程使用。

即常规文件操作需要从磁盘到页缓存再到用户主存的两次数据拷贝。而mmap操控文件，只需要从磁盘到用户主存的一次数据拷贝过程。因此mmap效率更高。

示例

1.创建文件zz，并用test.c代码向文件中写入数据。

2.分别指定不同大小的字符数写入，比较操作时长。

1.6mmap使用细节

1、使用mmap需要注意的一个关键点是，mmap映射区域大小必须是物理页大小(page_size)的整倍数（32位系统中通常是4k字节）。原因是，内存的最小粒度是页，而进程虚拟地址空间和内存的映射也是以页为单位。为了匹配内存的操作，mmap从磁盘到虚拟地址空间的映射也必须是页。

2、内核可以跟踪被内存映射的底层对象（文件）的大小，进程可以合法的访问在当前文件大小以内又在内存映射区以内的那些字节。也就是说，如果文件的大小一直在扩张，只要在映射区域范围内的数据，进程都可以合法得到，这和映射建立时文件的大小无关。具体情形参见“情形三”。

3、映射建立之后，即使文件关闭，映射依然存在。因为映射的是磁盘的地址，不是文件本身，和文件句柄无关。同时可用于进程间通信的有效地址空间不完全受限于被映射文件的大小，因为是按页映射。

在上面的知识前提下，我们下面看看如果大小不是页的整倍数的具体情况：

情形一：一个文件的大小是5000字节，mmap函数从一个文件的起始位置开始，映射5000字节到虚拟内存中。
分析：因为单位物理页面的大小是4096字节，虽然被映射的文件只有5000字节，但是对应到进程虚拟地址区域的大小需要满足整页大小，因此mmap函数执行后，实际映射到虚拟内存区域8192个 字节，5000~8191的字节部分用零填充。映射后的对应关系如下图所示：

此时：

• 读/写前5000个字节（0~4999），会返回操作文件内容。

• 读字节50008191时，结果全为0。写50008191时，进程不会报错，但是所写的内容不会写入原文件中 。

• 读/写8192以外的磁盘部分，会返回一个SIGSECV错误。

情形二：一个文件的大小是5000字节，mmap函数从一个文件的起始位置开始，映射15000字节到虚拟内存中，即映射大小超过了原始文件的大小。

分析：由于文件的大小是5000字节，和情形一一样，其对应的两个物理页。那么这两个物理页都是合法可以读写的，只是超出5000的部分不会体现在原文件中。由于程序要求映射15000字节，而文件只占两个物理页，因此8192字节~15000字节都不能读写，操作时会返回异常。如下图所示：

此时：

进程可以正常读/写被映射的前5000字节(0~4999)，写操作的改动会在一定时间后反映在原文件中。
对于5000~8191字节，进程可以进行读写过程，不会报错。但是内容在写入前均为0，另外，写入后不会反映在文件中。
对于8192~14999字节，进程不能对其进行读写，会报SIGBUS错误。
对于15000以外的字节，进程不能对其读写，会引发SIGSEGV错误。

情形三：一个文件初始大小为0，使用mmap操作映射了10004K的大小，即1000个物理页大约4M字节空间，mmap返回指针ptr。

分析：如果在映射建立之初，就对文件进行读写操作，由于文件大小为0，并没有合法的物理页对应，如同情形二一样，会返回SIGBUS错误。

但是如果，每次操作ptr读写前，先增加文件的大小，那么ptr在文件大小内部的操作就是合法的。例如，文件扩充4096字节，ptr就能操作ptr ~ [ (char)ptr + 4095]的空间。只要文件扩充的范围在1000个物理页（映射范围）内，ptr都可以对应操作相同的大小。

这样，方便随时扩充文件空间，随时写入文件，不造成空间浪费。

二、共享内存

共享内存就是容许两个不相关的进程访问同一个逻辑内存。共享内存是在两个正在运行的进程之间共享和传递数据的一种很是有效的方式。不一样进程之间共享的内存一般安排为同一段物理内存。进程能够将同一段共享内存链接到它们本身的地址空间中，全部进程均可以访问共享内存中的地址，就好像它们是由用C语言函数malloc分配的内存同样。而若是某个进程向共享内存写入数据，所作的改动将当即影响到能够访问同一段共享内存的任何其余进程。

共享内存区是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据。

用管道或者消息队列传递数据：

用共享内存传递数据：

共享内存有两种方式，即 shm（shared memory） 和 mmap 方式。前者直接共享物理内存，后者通过一个中间文件间接共享内存。

2.1内存映射和共享内存的区别

• 1、mmap保存到实际硬盘，实际存储并没有反映到主存上。优点：储存量可以很大（多于主存）；缺点：进程间读取和写入速度要比主存的要慢。——每个进程地址空间中开辟出一块空间进行映射

• 2、shm保存到物理存储器（主存），实际的储存量直接反映到主存上。优点，进程间访问速度（读写）比磁盘要快；缺点，储存量不能非常大（多于主存）——每个进程最终会映射到同一块物理内存

• 3、mmap系统调用并不是完全为了用于共享内存而设计的。它本身提供了不同于一般对普通文件的访问方式，进程可以像读写内存一样对普通文件的操作。而Posix或系统V的共享内存IPC则纯粹用于共享目的，当然mmap()实现共享内存也是其主要应用之一。

2.2共享内存常用的接口

int shm_open(const char *name, int oflag, mode_t mode); //用于创建或者打开共享内存文件,操作的文件一定是位于tmpfs文件系统里的,存放目录就是/dev/shm
void *mmap(void *addr, size_t length, int port, int flags, int fd, off_t offset);//将打开的文件映射到内存
int munmap(void *addr, size_t length);//取消内存映射
int shm_unlink(const char *name);//删除/dev/shm目录的文件
int ftruncate(int fd, off_t length);//重置文件大小

2.3共享内存用处

使用文件或者管道进行进程间通信会有很多局限性。管道只能在父进程和子进程间使用；通过文件共享，在处理效率上又差一些，而且访问文件描述符不如访问内存地址方便。

Linux系统在编程上提供的共享内存方案有三种：

• mmap内存共享映射

• XSI共享内存

• POSIX共享内存

2.4mmap内存共享映射

mmap本来是存储映射功能。它可以将一个文件映射到内存中，在程序里就可以直接使用内存地址对文件内容进行访问。

#include <sys/mman.h>
void *mmap(void *addr, size_t length, int port, int flags, int fd, off_t offset);
int munmap(void *addr, size_t length);

Linux通过系统调用fork派生出的子进程和父进程共用内存地址空间，Linux的mmap实现了一种可以在父子进程之间共享内存地址的方式。

1. 父进程将flags参数设置MAP_SHARED方式通过mmap申请一段内存。内存可以映射某个具体文件（fd），也可以不映射具体文件（fd置为-1，flag设置为MAP_ANONYMOUS）.

2. 父进程调用fork产生子进程，之后在父子进程内都可以访问到mmap所返回的地址，就可以共享内存了。

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <sys/file.h>
#include <sys/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;

    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;

    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\n", *shm_p);
    munmap(shm_p, sizeof(int));
    exit(0);
}

这段共享内存的使用是有竞争条件的。进程间通信不仅仅是通信这么简单，还要处理类似的这样的临界区代码。在这里，可以采用文件锁进行处理。但是共享内存使用文件锁显得不太协调。除了不方便和效率低下以外，文件锁还不能进行更高级的进程控制。这里可以使用信号量这种更高级的进程同步控制原语来实现相关功能。

下面这段程序用来帮助理解mmap的内存占用情况：

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

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

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);
}

申请了一段近2G的内存，并置0.观察内存变化

[zorro@zorrozou-pc0 sharemem]$ free -g
              total        used        free      shared  buff/cache   available
Mem:             15           2           2           0          10          11
Swap:            31           0          31
[zorro@zorrozou-pc0 sharemem]$ ./mmap_mem &
[1] 32036
[zorro@zorrozou-pc0 sharemem]$ free -g
              total        used        free      shared  buff/cache   available
Mem:             15           2           0           2          12           9
Swap:            31           0          31

可以看出，这段内存被记录到shared和buff/cache中了。mmap有一个缺点，那就是共享的内存只能在父进程和fork产生的子进程间使用，除此之外的其它进程无法得到共享内存段的地址。

2.5XSI共享内存

XSI是X/Open组织对UNIX定义的一套接口标准（X/Open System Interface）。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);

shmget的第三个参数，指定创建标志。支持的标志为：IPC_CREAT、IPC_EXCL。从Linux 2.6之后，还引入了支持大页的共享内存，标志为：SHM_HUGETLB、SHM_HUGE_2MB等。shemget除了可以创建一个新的共享内存外，还可以访问一个已经存在的内存，此时可以将shmflg置为0，不加任何标志打开。

shmget返回的int类型的shmid类似于文件描述符，注意只是类似，而并非同样的实现，所以，不能用select、poll、epoll这样的方法去控制一个XSI共享内存。对于一个XSI共享内存，其key是系统全局唯一的，这就方便其它进程使用同样的key，打开同样一段共享内存，以便进行进程间通信。而是用fork产生的子进程，可以直接通过shmid访问到相关共享内存段。这就是key的本质：系统中对XSI共享内存的全局唯一表示符。

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

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

key是通过ftok函数，使用一个约定好的文件名和proj_id生成的。ftok不会创建文件，所以必须指定一个存在并且进程可以访问的pathname路径。另外，ftok并不是根据文件的路径和文件名生成key的，在具体实现上，它使用的是指定文件的inode编号和文件所在设备的设备编号。所以，不同的文件名也可能得到同一个key（不同的文件名指向同一个inode，硬链接）。同样的文件名也不一定就能得到相同的key，一个文件名有可能被删除重建，这种行为会导致inode变化。

#include<unistd.h>
#include<stdlib.h>
#include<stdio.h>
#include<errno.h>
#include<fcntl.h>
#include<string.h>
#include<sys/file.h>
#include<sys/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;

    if((shm_key = ftok(PATHNAME, proj_id)) == -1) {
        perror("ftok()");
        exit(1);
    }

    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;

    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);
    }

    *shm_p = 0;

    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\n", *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);
}

在某些情况下，也可以不通过一个key来创建共享内存。此时可以在key的参数所在位置填IPC_PRIVATE,这样内核会在保证不冲突的共享内存段id的情况下新建一段共享内存。因为只能是创建，所以flag位一定是IPC_CREAT。可以将shmid传给子进程。

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

shmctl还可以查看、修改共享内存的相关属性，可以在man 2 shmctl中查看。在系统中还可以使用ipcs -m 命令查看系统中所有共享内存的信息。

ipcs - provide information on ipc facilities
ipcs [-asmq] [-tclup]
ipcs [-smq] -i id

-m 共享内存
-q 消息队列
-s 信号量数组
-a all（缺省）

输出选项：

-t time
-p pid
-c creator
-l limits
-u summary

在Linux系统中，使用XSI共享内存调用shmget时，可以通过设置shmflg参数来申请大页内存（huge pages）。

SHM_HUGETLB(since Linux 2.6)
SHM_HUGE_2MB, SHM_HUGE_1GB(since Linux 3.8)

使用大页内存的好处是提高内核对内存管理的处理效率。因为在相同内存大小的情况下，使用大页内存（2M一页）将比使用一般内存页（4K一页）的内存页管理的数量大大减少，从而减少内存页表项的缓存压力和CPU cache缓存内存地址的映射压力。但是需要注意一些地方：

• 大页内存不能交换（SWAP）

• 使用不当时可能造成更大的内存泄露

• 大页内存需要使用root权限

• 需要修改系统配置

shm_id = shmget(IPC_PRIVATE, MEMSIZE, SHM_HUGETLB|0600)

如果要申请2G以下的大页内存，需要系统预留2G以上的大页内存。

echo 2048 > /proc/sys/vm/nr_hugepages
cat /proc/meminfo | grep -i huge
    AnonHugePages:      841728 KB
    HugePages_Total:    2020
    HugePages_Free:     2020
    HugePages_Rsvd:     0
    HugePages_Surp:     0
    Hugepagesize:       2048 kB

2048是页数，每页2M。

还需要注意共享内存的限制：

echo 2147483648 > /proc/sys/kernel/shmmax
echo 33554432 > /proc/sys/kernel/shmall

/proc/sys/kernel/shmall：限制系统用在共享内存上的内存页总数。一页一般是4k（可以通过getconf PAGE_SIZE查看)

/proc/sys/kernel/shmmax：限制一个共享内存段的最大长度，单位是字节

/proc/sys/kernel/shmmni：限制整个系统可以创建的最大的共享内存段的个数

2.6POSIX共享内存

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

tmpfs是将一部分内存空间用作文件系统，一般挂在/dev/shm目录。

Linux提供的POSIX共享内存，实际上就是在/dev/shm下创建一个文件，并将其mmap之后映射其内存地址即可。可以通过man shm_overview查看使用方法。

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <sys/file.h>
#include <sys/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\n", *shm_p);
    munmap(shm_p, sizeof(int));
    close(shmfd);
    shm_unlink(SHMPATH);
    exit(0);
}

编译该段代码的时候需要指定一个库，-lrt，这是linux的real time库。

• shm_open的SHMPATH参数是一个路径，这个路径默认放在系统的/dev/shm目录下。这是shm_open封装好的，保证文件一定在tmpfs下。

• 使用ftruncate改变共享内存的大小，实际就是改变文件的长度。

• shm_unlink实际就是unlink系统调用的封装。如果不做unlink操作，那么文件会一直存在/dev/shm目录下。

• 关闭共享内存描述符，使用close.

2.7修改共享内存内核配置

SHMMAX一个进程可以在它的虚拟地址空间分配给一个共享内存端的最大大小（单位是字节）

echo 2147483648 > /proc/sys/kernel/shmmax
或
sysctl -w kernel.shmmax=2147483648
或
echo "kenerl.shmmax=2147483648" >> /etc/sysctl.conf

SHMMNI系统范围内共享内存段的数量

echo 4096 > /proc/sys/kernel/shmmni
或
sysctl -w kernel.shmmni=4096
或
echo "kernel.shmmni=4096" >> /etc/sysctl.conf

SHMALL这个参数设置了系统范围内共享内存可以使用的页数。单位是PAGE_SIZE（通常是4096，可以通过getconf PAGE_SIZE获得）

echo 2097152 > /proc/sys/kernel/shmall
或
sysctl -w kernel.shmall=2097152
或
echo "kernel.shmall=2097152" >> /etc/sysctl.conf

移除共享内存执行ipcs -m查看系统所有的共享内存。如果status字段是dest，表明这段共享内存需要被删除。

ipcs -m -i $shmid

内存映射的主要优势包括：

1. 高效读写：由于文件直接映射到内存中，读取和写入数据就像对待普通变量一样高效。

2. 省去复制开销：不需要将数据从磁盘复制到用户空间或者从用户空间复制回磁盘，节省了额外的数据复制开销。

3. 简化编程：使用内存映射可以将文件视为一个连续的字节数组，在访问文件时不需要关注具体的IO操作，简化了编程逻辑。

4. 共享内存：多个进程可以同时映射同一个文件，实现共享数据，并且修改会反映在所有进程中。

然而，使用内存映射也有一些注意事项：

1. 内存消耗：如果处理大型文件或者多个文件，可能占用较大的物理内存空间。

2. 文件更新同步：当多个进程同时访问并修改同一个文件时，需要考虑如何进行同步，以避免数据不一致的问题。

3. 适用性限制：内存映射主要适用于对文件进行顺序读写和随机访问，不适合频繁修改文件内容的场景。

精品文章推荐阅读：

• 深入理解C++内存管理：指针、引用和内存分配

• 打破常规，Linux内核新的数据结构上场maple tree

• 深入挖掘Linux内核源码：揭秘其惊人的架构和设计
  

• 高效网络通信技术揭秘，Socket原理与实践
  

• 解密Linux内核神器：内存屏障的秘密功效与应用方法

• Linux内核文件系统：比万物之神还要强大的存储魔法！
  

• 内存分配不再神秘：深入剖析malloc函数实现原理与机制

• 探索网络通信核心技术，手写TCP/IP用户态协议栈，让性能飙升起来