将最近网上搜索的资料统一整理下，方便后续复查。

一、什么是mmap

mmap是一种内存映射文件的方法，即将一个文件或者其它对象映射到进程的地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系，函数原型如下 void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

实现这样的映射关系后，进程就可以采用指针的方式读写操作这一段内存，而系统会自动回写脏页面到对应的文件磁盘上，即完成了对文件的操作而不必再调用read,write等系统调用函数。如下图所示

mmap除了可以减少read,write等系统调用以外，还可以减少内存的拷贝次数，比如在read调用时，一个完整的流程是操作系统读磁盘文件到页缓存，再从页缓存将数据拷贝到read传递的buffer里，而如果使用mmap之后，操作系统只需要将磁盘读到页缓存，然后用户就可以直接通过指针的方式操作mmap映射的内存，减少了从内核态到用户态的数据拷贝。

mmap适合于对同一块区域频繁读写的情况，比如一个64M的文件存储了一些索引信息，我们需要频繁修改并持久化到磁盘，这样可以将文件通过mmap映射到用户虚拟内存，然后通过指针的方式修改内存区域，由操作系统自动将修改的部分刷回磁盘，也可以自己调用msync手动刷磁盘。

内核角度分析mmap原理，这篇博客图文并茂，直接参考就好了。 linux内存映射mmap原理分析 - 鱼思故渊的专栏 - CSDN博客 https://blog.csdn.net/yusiguyuan/article/details/23388771

映射只不过是映射到虚拟内存，不用担心映射的文件太大。

每个进程的4G内存空间只是虚拟内存空间，每次访问内存空间的某个地址，都需要把地址翻译为实际物理内存地址
所有进程共享同一物理内存，每个进程只把自己目前需要的虚拟内存空间映射并存储到物理内存上。

详细虚拟内存的内容还是参考大神总结

linux 进程的虚拟内存 - fengxin的博客 - CSDN博客 https://blog.csdn.net/fengxinlinux/article/details/52071766

二、mmap参数说明

映射文件或设备到内存中，取消映射就是munmap函数。

语法如下：

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

该函数主要用途有三个：

将普通文件映射到内存中，通常在需要对文件进行频繁读写时使用，用内存读写取代I/O读写，以获得较高的性能；
将特殊文件进行匿名内存映射，为关联进程提供共享内存空间；
为无关联的进程间的Posix共享内存（SystemV的共享内存操作是shmget/shmat）

我们来看下函数的入参选择：

➢ 参数addr：

指向欲映射的内存起始地址，通常设为 NULL，代表让系统自动选定地址，映射成功后返回该地址。

➢ 参数length：

代表将文件中多大的部分映射到内存。

➢ 参数prot：

映射区域的保护方式。可以为以下几种方式的组合：

PROT_EXEC 映射区域可被执行

PROT_READ 映射区域可被读取

PROT_WRITE 映射区域可被写入

PROT_NONE 映射区域不能存取

➢ 参数flags：

影响映射区域的各种特性。在调用mmap()时必须要指定MAP_SHARED 或MAP_PRIVATE。

MAP_FIXED 如果参数start所指的地址无法成功建立映射时，则放弃映射，不对地址做修正。通常不鼓励用此。

MAP_SHARED对映射区域的写入数据会复制回文件内，而且允许其他映射该文件的进程共享。

MAP_PRIVATE 对映射区域的写入操作会产生一个映射文件的复制，即私人的“写入时复制”（copy on write）对此区域作的任何修改都不会写回原来的文件内容。

MAP_ANONYMOUS建立匿名映射。此时会忽略参数fd，不涉及文件，而且映射区域无法和其他进程共享。

MAP_DENYWRITE只允许对映射区域的写入操作，其他对文件直接写入的操作将会被拒绝。

MAP_LOCKED 将映射区域锁定住，这表示该区域不会被置换（swap）。

➢ 参数fd：

要映射到内存中的文件描述符。如果使用匿名内存映射时，即flags中设置了MAP_ANONYMOUS，fd设为-1。

➢ 参数offset：

文件映射的偏移量，通常设置为0，代表从文件最前方开始对应，offset必须是分页大小的整数倍。

返回说明

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

EACCES：访问出错

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

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

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

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

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

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

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

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

SIGSEGV：试着向只读区写入

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

三、mmap与直接IO（read、write）的效率比较

不能简单的说哪个效率高，要看具体实现与具体应用。 write read mmap实际流程如下：

无论是通过mmap方式或read/write方式访问文件在内核中都必须经过两个缓存：一个是用address_space来组织的以页为基础的缓存；一个是以buffer来组织的缓存，但实际上这两个缓存只是同一个缓冲池里内容的不同组织方式。当需要从文件读写内容时，都经过 address_space_operation中提供的函数也就是说路径是一致的。如果是用read/write方式，用户须向内核指定要读多少，内核再把得到的内容从内核缓冲池拷向用户空间；写也须要有一个大致如此的过程。

mmap的优势在于通过把文件的某一块内容映射到用户空间上，用户可以直接向内核缓冲池读写这一块内容，这样一来就少了内核与用户空间的来回拷贝所以通常更快。但 mmap方式只适用于更新、读写一块固定大小的文件区域而不能做像诸如不断的写内容进入文件导到文件增长这类的事。

二者的主要区别在于，与mmap和memcpy相比，read和write执行了更多的系统调用，并做了更多的复制。read和write将数据从内核缓冲区中复制到应用缓冲区，然后再把数据从应用缓冲区复制到内核缓冲区。而mmap和memcpy则直接把数据从映射到地址空间的一个内核缓冲区复制到另一个内核缓冲区。当引用尚不存在的内存页时，这样的复制过程就会作为处理页错误的结果而出现（每次错页读发生一次错误，每次错页写发生一次错误）。

所以他们两者的效率的比较就是系统调用和额外的复制操作的开销和页错误的开销之间的比较，哪一个开销少就是哪一个表现更好。用mmap可以避免与读写打交道，这样可以简化程序逻辑，有利于编程实现。

系统调用mmap()可以将某文件映射至内存(进程空间)，如此可以把对文件的操作转为对内存的操作，以此避免更多的lseek()与read()、write()操作，这点对于大文件或者频繁访问的文件而言尤其受益。但有一点必须清楚：mmap的addr与offset必须对齐一个内存页面大小的边界，即内存映射往往是页面大小的整数倍，否则maaped_file_size%page_size内存空间将被闲置浪费。映射时，指定offset最好是内存页面大小的整数倍。

内存文件映射的使用：

(1)大数据量文件的读取，有效的提高磁盘和内存间数据通信的性能；

(2）进程间快速的共享内存，实现进程间高效的通信。

内存映射文件性能高于普通IO的原因：

内存文件映射和普通的文件IO都是要通过文件系统和硬盘驱动拷贝数据到内存中，内存文件映射数据越大越快主要是：

（1）实际拷贝数据前，需要建立映射信息，内存文件映射已经提前准备好了映射关系，内核调度好了进程内的内存块，交付给内核进行了预先处理，内存文件映射会消耗掉一些时间。

（2）实际拷贝时候，内存文件映射将磁盘数据直接拷贝到用户进程内存空间只进行了一次拷贝，而普通的IO是先将文件拷贝到内核缓存空间，然后才拷贝到用户进程内存空间，进行了两次拷贝。

下面是一个使用普通的fread函数和内存映射文件函数，读取不同大小的磁盘文件的性能分析表：

综合：当读写磁盘文件的数据较小(少于1MB)时候，使用内存文件映射和普通IO是差异很小的，所以建议使用普通IO就可以了；当很多文件的大小在几十MB, 几百MB, 或者1GB以上的文件数据需要进行较频繁的访问，或者一开始需要全部加载这些大文件的时候，那么就需要考虑使用内存文件映射了。

四、网上测试实例

（1）demo1 演示一下,将文件/tmp/file_mmap中的字符转成大写，分别使用mmap与read/write二种方法实现。先创建/tmp/file_mmap文件，该文件写入www.baidu.com，使用strace统计系统调用。

/*
* @file: t_mmap.c
*/
#include <stdio.h>
#include <ctype.h>
#include <sys/mman.h> /*mmap munmap*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
 
int main(int argc, char *argv[])
{
 int fd;
 char *buf;
 off_t len;
 struct stat sb;
 char *fname = "/tmp/file_mmap";
 
 fd = open(fname, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
 if (fd == -1)
 {
  perror("open");
  return 1;
 }
 if (fstat(fd, &sb) == -1)
 {
  perror("fstat");
  return 1;
 }
 
 buf = mmap(0, sb.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
 if (buf == MAP_FAILED)
 {
  perror("mmap");
  return 1;
 }
 
 if (close(fd) == -1)
 {
  perror("close");
  return 1;
 }
 
 for (len = 0; len < sb.st_size; ++len)
 {
  buf[len] = toupper(buf[len]);
  /*putchar(buf[len]);*/
 }
 
 if (munmap(buf, sb.st_size) == -1)
 {
  perror("munmap");
  return 1;
 }
 return 0;
}

自己测试运行结果：

root@chenwr-pc:/home/workspace/test# gcc tmp.c -o run 
root@chenwr-pc:/home/workspace/test# strace ./run 
execve("./run", ["./run"], [/* 22 vars */]) = 0
brk(0)                                  = 0x1ffa000
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=106932, ...}) = 0
mmap(NULL, 106932, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7fcab05de000
close(3)                                = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
open("/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\0\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0P \2\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=1857312, ...}) = 0
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fcab05dd000
mmap(NULL, 3965632, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7fcab000e000
mprotect(0x7fcab01cc000, 2097152, PROT_NONE) = 0
mmap(0x7fcab03cc000, 24576, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1be000) = 0x7fcab03cc000
mmap(0x7fcab03d2000, 17088, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7fcab03d2000
close(3)                                = 0
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fcab05db000
arch_prctl(ARCH_SET_FS, 0x7fcab05db740) = 0
mprotect(0x7fcab03cc000, 16384, PROT_READ) = 0
mprotect(0x600000, 4096, PROT_READ)     = 0
mprotect(0x7fcab05f9000, 4096, PROT_READ) = 0
munmap(0x7fcab05de000, 106932)          = 0
open("/tmp/file_mmap", O_RDWR|O_CREAT, 0600) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=14, ...}) = 0
mmap(NULL, 14, PROT_READ|PROT_WRITE, MAP_SHARED, 3, 0) = 0x7fcab05f8000
close(3)                                = 0
munmap(0x7fcab05f8000, 14)              = 0
exit_group(0)                           = ?
+++ exited with 0 +++

该文件已经变成大写。

root@chenwr-pc:/tmp# cat file_mmap 
WWW.BAIDU.COM

网上该demo的说明：

open("/tmp/file_mmap", O_RDWR|O_CREAT, 0600) = 3 //open，返回fd=3
fstat64(3, {st_mode=S_IFREG|0644, st_size=18, ...}) = 0 //fstat, 即文件大小18
mmap2(NULL, 18, PROT_READ|PROT_WRITE, MAP_SHARED, 3, 0) = 0xb7867000 //mmap文件fd=3
close(3)  = 0 //close文件fd=3
munmap(0xb7867000, 18)= 0  //munmap，移除0xb7867000这里的内存映射
这里mmap的addr是0(NULL)，offset是18，并不是一个内存页的整数倍，即有4078bytes（4kb-18）内存空间被闲置浪费了。

（2）demo2 read的方式

#include <stdio.h>
#include <ctype.h>
#include <sys/mman.h> /*mmap munmap*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
 int fd, len;
 char *buf;
 char *fname = "/tmp/file_mmap";
 ssize_t ret;
 struct stat sb;
 
 fd = open(fname, O_CREAT|O_RDWR, S_IRUSR|S_IWUSR);
 if (fd == -1)
 {
  perror("open");
  return 1;
 }
 if (fstat(fd, &sb) == -1)
 {
  perror("stat");
  return 1;
 }
 
 buf = malloc(sb.st_size);
 if (buf == NULL)
 {
  perror("malloc");
  return 1;
 }
 ret = read(fd, buf, sb.st_size);
 for (len = 0; len < sb.st_size; ++len)
 {
  buf[len] = toupper(buf[len]);
  /*putchar(buf[len]);*/
 }
 
 lseek(fd, 0, SEEK_SET);
 ret = write(fd, buf, sb.st_size);
 if (ret == -1)
 {
  perror("error");
  return 1;
 }
 
 if (close(fd) == -1)
 {
  perror("close");
  return 1;
}
free(buf);
 return 0;
}

自己测试运行的结果：

root@chenwr-pc:/home/workspace/test# strace ./run 
execve("./run", ["./run"], [/* 22 vars */]) = 0
brk(0)                                  = 0x13ac000
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=106932, ...}) = 0
mmap(NULL, 106932, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7fb98f1d7000
close(3)                                = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
open("/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\0\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0P \2\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=1857312, ...}) = 0
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fb98f1d6000
mmap(NULL, 3965632, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7fb98ec07000
mprotect(0x7fb98edc5000, 2097152, PROT_NONE) = 0
mmap(0x7fb98efc5000, 24576, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1be000) = 0x7fb98efc5000
mmap(0x7fb98efcb000, 17088, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7fb98efcb000
close(3)                                = 0
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fb98f1d4000
arch_prctl(ARCH_SET_FS, 0x7fb98f1d4740) = 0
mprotect(0x7fb98efc5000, 16384, PROT_READ) = 0
mprotect(0x600000, 4096, PROT_READ)     = 0
mprotect(0x7fb98f1f2000, 4096, PROT_READ) = 0
munmap(0x7fb98f1d7000, 106932)          = 0
open("/tmp/file_mmap", O_RDWR|O_CREAT, 0600) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=14, ...}) = 0
brk(0)                                  = 0x13ac000
brk(0x13cd000)                          = 0x13cd000
read(3, "www.baidu.com\n", 14)          = 14
lseek(3, 0, SEEK_SET)                   = 0
write(3, "WWW.BAIDU.COM\n", 14)         = 14
close(3)                                = 0
exit_group(0)                           = ?
+++ exited with 0 +++

网上该demo的说明：

open("/tmp/file_mmap", O_RDWR|O_CREAT, 0600) = 3 //open, fd=3
fstat64(3, {st_mode=S_IFREG|0644, st_size=18, ...}) = 0 //fstat, 其中文件大小18
brk(0) = 0x9845000  //brk, 返回当前中断点
brk(0x9866000)  = 0x9866000  //malloc分配内存,堆当前最后地址
read(3, "www.perfgeeks.com\n", 18)= 18 //read
lseek(3, 0, SEEK_SET) = 0 //lseek
write(3, "WWW.PERFGEEKS.COM\n", 18)  = 18 //write
close(3)  = 0

这里通过read()读取文件内容,toupper()后，调用write()写回文件。因为文件太小，体现不出read()/write()的缺点：频繁访问大文件，需要多个lseek()来确定位置。每次编辑read()/write()，在物理内存中的双份数据。当然，不可以忽略创建与维护mmap()数据结构的成本。需要注意：并没有具体测试mmap vs read/write，即不能一语断言谁孰谁劣，具体应用场景具体评测分析。你只是要记住：mmap内存映射文件之后，操作内存即是操作文件，可以省去不少系统内核调用(lseek, read, write)。

五、自己写的demo

#include <stdio.h>
#include <ctype.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <time.h>
#define INT64U          unsigned long long 

#define MSG_ERR     1
#define MSG_WARN    2
#define MSG_INFO    3
#define MSG_DBG     4
#define MSG_NOR     5

#define MSG_HEAD     ("libfat->")
#define PRTMSG(level, fmt, args...)\
do {\
    if (level <= MSG_NOR) {\
        if (level <= MSG_NOR) {\
            printf("%s, %s, line %d: " fmt,__FILE__,__FUNCTION__,__LINE__, ##args);\
        } else {\
            printf("%s:" fmt, MSG_HEAD, ##args);\
        }\
    }\
} while(0)

typedef unsigned char       BOOLEAN;
typedef unsigned char       INT8U;
typedef unsigned int        INT16U;
typedef unsigned long       INT32U;

typedef signed char         INT8S;
typedef signed int          INT16S;
typedef signed long         INT32S;

char *filename = "./lt00001";
//char *filename = "/mnt/sdisk/video/lt00004";
char *data = "1111111111\
2222222222\
3333333333\
4444444444";
INT32S data_len = 40;//单次写入的数据长度
struct timeval t_start, t_end;
struct stat file_info;
long cost_time = 0;
int write_num = 1000;

INT32S mmap_write(INT32S fd, INT64U offset, void *data, INT32S data_len)
{
    char *buf = NULL;

 	if (fstat(fd, &file_info) == -1) {
		perror("fstat");
		PRTMSG(MSG_ERR, "[cwr] Get file info failed\n");
		return -1;
	}
	buf = mmap(0, file_info.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
 	if (buf == MAP_FAILED) {
		perror("mmap");
		PRTMSG(MSG_ERR, "[cwr] mmap failed\n");
		return -1;
	} 
	//offset = (INT64U)((order)*sizeof(FAT_FILE_LIST_T));
	memcpy(buf+offset, data, data_len);
	if (munmap(buf, file_info.st_size) == -1) {
		perror("munmap");
		PRTMSG(MSG_ERR, "[cwr] munmap failed\n");
		return -1;
	}
	return data_len;
}
int write_test()
{
	int fd, ret, i, data_size;
	INT64U ret64, offset;
	int ret_len = 0;
	time_t starttime, endtime;

	fd = open(filename, O_RDWR);
	if (fd < 0) {
		printf("[cwr] open file faild\n");
	}
	gettimeofday(&t_start, NULL);
	for (i=0; i<write_num; i++) {
		offset = i*data_len;
		ret64 = lseek64(fd, offset, SEEK_SET);
        if (ret64 == -1LL) {
            printf("lseek data fail\n");
            return -1;
        }
		ret_len = write(fd, data, data_len);
		if (ret_len != data_len) {
			printf("[cwr] count = %d; write error\n", i);
			close(fd);
			return -1;
		}
	}
	gettimeofday(&t_end, NULL);
	printf("[cwr] test end, count = %d\n", i);
	close(fd);
	return 0;
}
int mmap_write_test()
{
	 int fd, ret, i, data_size;
	 INT64U ret64, offset;
	 int ret_len = 0;

    fd = open(filename, O_RDWR);
    if (fd < 0) {
        printf("[cwr] open file faild\n");
    }
	gettimeofday(&t_start, NULL);
    for (i=0; i<write_num; i++) {
        offset = i*data_len;
        ret_len = mmap_write(fd, offset, data, data_len);
        if (ret_len != data_len) {
            printf("[cwr] count = %d; mmap write error\n", i);
            close(fd);
            return -1;
        }
    }
	gettimeofday(&t_end, NULL);
    printf("[cwr] mmap write test end, count = %d\n", i);

	close(fd);
    return 0;

}
void main()
{
	int ret;

	memset(&file_info, 0, sizeof(file_info));
#if 1
	ret = write_test();

	if (ret != 0) {
		printf("[cwr] write_test failed\n");
	}
#endif
#if 0
    ret = mmap_write_test();

    if (ret != 0) {
        printf("[cwr] mmap_write_test failed\n");
    }
#endif
	cost_time = t_end.tv_usec - t_start.tv_usec;
	printf("Start time: %ld us\n", t_start.tv_usec);
	printf("End time: %ld us\n", t_end.tv_usec);
	printf("Cost time: %ld us\n", cost_time);

	while(1) {
		sleep(1);
	}
}

运行结果：

write的方式获取的时间

使用mmap的方式去操作

后续不映射整个文件的空间大小，而是映射要写入数据的长度40字节

buf = mmap(0, 40, PROT_READ|PROT_WRITE, MAP_SHARED, fd, offset*4*1024)

为何测试mmap效率并没有更高效。

六、参考资料

mmap函数使用与实例详解 - u013525455的博客 - CSDN博客 https://blog.csdn.net/u013525455/article/details/52582839

linux mmap 内存映射 mmap() vs read()/write()/lseek()的实例演示 - Linux操作系统：Ubuntu_Centos_Debian - 红黑联盟 https://www.2cto.com/kf/201806/753798.html

Linux文件读写机制及优化方式 - Linux就该这么学 - 博客园 https://www.cnblogs.com/linuxprobe/articles/5925397.html

在linux中使用内存映射(mmap)操作文件 - 随意的风的专栏 - CSDN博客 https://blog.csdn.net/windgs_yf/article/details/80856458

linux内存管理——mmap函数详解 - badman250的专栏 - CSDN博客 https://blog.csdn.net/notbaron/article/details/80019134

函数sync、fsync与fdatasync总结整理 - pugu12的专栏 - CSDN博客 https://blog.csdn.net/pugu12/article/details/46860143

file - Why (ftruncate+mmap+memcpy) is faster than (write)? - Stack Overflow https://stackoverflow.com/questions/38194948/why-ftruncatemmapmemcpy-is-faster-than-write/38374266

mmap与直接IO（read、write）的效率比较 - 绯浅yousa的笔记 - CSDN博客 https://blog.csdn.net/qq_15437667/article/details/72084829

测试linux下 fprintf fwrite write mmap 等写文件的速度 - penzchan的专栏 - CSDN博客 https://blog.csdn.net/penzchan/article/details/18660307

mmap和write性能对比-bjpiao-ChinaUnix博客 http://blog.chinaunix.net/uid-26575352-id-3761850.html

linux内存映射mmap原理分析 - 鱼思故渊的专栏 - CSDN博客 https://blog.csdn.net/yusiguyuan/article/details/23388771

linux 进程的虚拟内存 - fengxin的博客 - CSDN博客 https://blog.csdn.net/fengxinlinux/article/details/52071766

[原创] 深入剖析mmap-从三个关键问题说起 - 简书 https://www.jianshu.com/p/eece39beee20