3.1 映射的本质#

mmap 在进程的虚拟地址空间中划出一块区域，让这块区域的虚拟页与文件内容建立对应关系。调用 mmap() 本身并不把文件读进内存——它只是修改页表。当进程访问某个尚未加载的虚拟页时，CPU 触发缺页中断（Page Fault），内核才真正从磁盘读取对应的文件块到物理页中。

3.2 mmap 系统调用#

1
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
• fd：要映射的文件描述符
• offset：文件偏移量，必须是页大小的整数倍

调用成功返回映射区域的起始指针，失败返回 MAP_FAILED。

3.3 共享映射与私有映射#

MAP_SHARED 和 MAP_PRIVATE 决定了写入行为：

MAP_PRIVATE 的写入本质上就是写时复制。进程 A 和进程 B 映射同一个文件，都用 MAP_PRIVATE。A 修改了某个页面，内核为 A 创建一份私有副本，B 看到的仍然是原始内容。

3.4 匿名映射#

MAP_ANONYMOUS 不需要文件支持，映射的内存初始化为零。用途包括：

• malloc() 分配大块内存时，glibc 内部用 mmap(MAP_ANONYMOUS) 实现
• 线程栈分配——每个线程的栈都是一块匿名映射
• 父子进程之间的私有共享内存（MAP_SHARED|MAP_ANONYMOUS，fork() 后共享）

1
// 分配 4MB 匿名内存，初始化为零
2
void *mem = mmap(NULL, 4 * 1024 * 1024,
3
                 PROT_READ | PROT_WRITE,
4
                 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

3.5 缺页中断的生命周期#

1. 进程访问映射区域中尚未加载的虚拟地址
2. CPU 查页表，发现该页不存在，触发缺页中断
3. 内核的中断处理程序检查该地址属于 mmap 映射
4. 内核从磁盘读取对应的文件块到物理页
5. 内核更新页表，将虚拟页指向物理页
6. 恢复进程执行，重新执行触发中断的那条指令

这个过程对进程完全透明——就像数据本来就在内存里一样。

3.6 性能特征#

mmap 更快的场景：

• 顺序读取大文件：缺页中断预读（readahead）可以有效利用磁盘带宽
• 随机访问大文件中分散的少量数据：不需要把整个文件 read() 进来
• 多进程共享同一文件：共享映射避免重复加载

mmap 不一定更快的场景：

• 随机读取小文件：缺页中断的开销可能比一次 read() 还大
• 文件远大于物理内存：频繁的页面换入换出导致性能骤降
• 只需要文件头几字节：映射整个文件浪费虚拟地址空间

3.7 注意事项#

• 文件截断：如果文件在映射期间被截断，访问超出新文件末尾的页面会产生 SIGBUS 信号，导致进程崩溃
• 32 位系统限制：32 位进程的虚拟地址空间只有 3GB（用户态），映射大文件可能耗尽地址空间
• 映射生命周期：进程退出或调用 munmap() 后映射自动解除，MAP_SHARED 的脏页会写回文件
• 对齐要求：offset 必须是页大小的整数倍，映射长度会向上取整到页大小

4.1 mmap vs read/write#

4.2 mmap vs sendfile#

sendfile() 在内核态直接把文件内容发送到 socket，全程不经过用户空间。适合「从磁盘到网络」的零拷贝传输，比如静态文件服务器。mmap 更通用——映射后可以任意读写、多进程共享，但 mmap 的写入需要经过用户空间，不算完全零拷贝。

4.3 共享内存机制对比#

POSIX 共享内存的底层实现其实就是 mmap 映射 tmpfs 上的文件。三种机制在数据传输效率上没有本质区别。

4.4 Go 中的 mmap#

Go 通过 syscall 包提供 mmap 支持：

1
data, err := syscall.Mmap(fd, 0, length,
2
    syscall.PROT_READ|syscall.PROT_WRITE,
3
    syscall.MAP_SHARED)

返回的 data 是 []byte 切片，可以直接读写。第三方库 golang.org/x/exp/mmap 提供了更友好的只读映射接口。

4.5 Node.js/TypeScript 中的 mmap#

Node.js 没有原生的 mmap API。常用的替代方案：

• fs.readFileSync()：把整个文件读进 Buffer，简单但不适合大文件
• fs.createReadStream()：流式读取，适合顺序处理
• 第三方库如 mmap-io：通过 N-API 封装 C 的 mmap 调用

1
// Node.js 中模拟 mmap 风格的文件访问
2
import { openSync, readSync } from 'fs';
3

4
const fd = openSync('large.dat', 'r');
5
const buffer = Buffer.alloc(4096);
6
// 按需读取特定偏移量的数据
7
readSync(fd, buffer, 0, 4096, offset);

如果需要真正的 mmap，通常的做法是用 C++ 编写 N-API 插件，或者用子进程调用 C 程序。

5.1 Go：用 mmap 映射文件并读写#

1
package main
2

3
import (
4
    "fmt"
5
    "os"
6
    "syscall"
7
)
8

9
func main() {
10
    // 打开文件
11
    f, err := os.OpenFile("test.dat", os.O_RDWR|os.O_CREATE, 0644)
12
    if err != nil {
13
        panic(err)
14
    }
15
    defer f.Close()
16

17
    // 确保文件有内容
18
    size := 4096
19
    if err := f.Truncate(int64(size)); err != nil {
20
        panic(err)
21
    }
22

23
    // 映射文件到内存
24
    data, err := syscall.Mmap(int(f.Fd()), 0, size,
25
        syscall.PROT_READ|syscall.PROT_WRITE,
26
        syscall.MAP_SHARED)
27
    if err != nil {
28
        panic(err)
29
    }
30

31
    // 通过切片直接读写，就像操作普通内存
32
    copy(data, []byte("hello mmap"))
33
    fmt.Printf("内容: %s\n", data[:10])
34

35
    // 解除映射（MAP_SHARED 的脏页会写回文件）
36
    if err := syscall.Munmap(data); err != nil {
37
        panic(err)
38
    }
39
}

关键点：data 是 []byte 类型，对它的修改会直接反映到文件上（MAP_SHARED 模式）。调用 Munmap 后，内核将脏页写回磁盘。

5.2 TypeScript：Buffer 与按需读取#

1
import { openSync, readSync, writeSync, closeSync } from 'fs';
2

3
class MmapLikeReader {
4
  private fd: number;
5
  private pageSize = 4096;
6
  private cache: Map<number, Buffer> = new Map();
7

8
  constructor(filepath: string) {
9
    this.fd = openSync(filepath, 'r');
10
  }
11

12
  // 按页缓存，模拟 mmap 的按需加载
13
  read(offset: number, length: number): Buffer {
14
    const pageStart = Math.floor(offset / this.pageSize) * this.pageSize;
15
    if (!this.cache.has(pageStart)) {
16
      const buf = Buffer.alloc(this.pageSize);
17
      readSync(this.fd, buf, 0, this.pageSize, pageStart);
18
      this.cache.set(pageStart, buf);
19
    }
20
    const page = this.cache.get(pageStart)!;
21
    const pageOffset = offset - pageStart;
22
    return page.subarray(pageOffset, pageOffset + length);
23
  }
24

25
  close(): void {
26
    closeSync(this.fd);
27
  }
28
}
29

30
// 使用
31
const reader = new MmapLikeReader('large.dat');
32
const data = reader.read(1024, 16);
33
console.log(data.toString());
34
reader.close();

这不是真正的 mmap——数据仍然经过用户空间缓冲区。但在 Node.js 没有原生 mmap 支持的情况下，按页缓存的模式可以在一定程度上模拟按需加载的行为。

6.1 SQLite#

SQLite 是 mmap 最著名的生产级用户。当 PRAGMA mmap_size 设置为非零值时，SQLite 用 mmap 访问数据库文件，而不是传统的 read()/write()。对于只读查询，mmap 可以减少系统调用次数，提升小规模随机读取的性能。SQLite 在检测到 mmap 失败或文件被外部修改时，会自动回退到 read() 路径。

6.2 PostgreSQL#

PostgreSQL 的共享缓冲区（Shared Buffers）不是直接用 mmap 实现的——它用 shm_open + mmap 分配共享内存区域，然后在上面自行管理缓冲池。数据库页面的换入换出策略由 PostgreSQL 的缓存替换算法控制，而不是依赖操作系统的页面置换。这种设计让数据库对缓存行为有完全的控制权。

6.3 Redis#

Redis 在 RDB 持久化和 AOF 重写时使用 mmap。bgrewriteaof 生成新的 AOF 文件后，Redis 用 mmap 将文件映射到内存，然后通过 write() 将映射内容发送给从节点。这种方式避免了额外的用户态拷贝。AOF 重写期间的子进程也通过 mmap 读取父进程的内存快照（配合 fork() 的 COW 机制），减少内存占用。