C++ 用户态内存映射：`mmap` 在高性能 I/O 和共享内存中的高级应用

哈喽，各位好！今天咱们聊聊C++里一个既强大又有点神秘的家伙——mmap。这货就像个魔法师，能把文件或者设备直接“映射”到你的内存里，让你像访问数组一样访问它们，是不是听起来就很酷？

咱们今天不光要搞清楚mmap是什么，还要看看它在高性能I/O和共享内存里是怎么大显身手的，最后还会分享一些使用mmap时需要注意的“坑”。准备好了吗？Let’s dive in!

第一幕：mmap 闪亮登场——这货到底是个啥？

先别急着被专业术语吓跑，mmap其实没那么难。你可以把它想象成一个“传送门”，一头连着你的进程地址空间，另一头连着磁盘上的文件或者其他存储设备。通过这个传送门，你可以直接读写文件，而不需要像传统I/O那样，先从磁盘读到内核缓冲区，再从内核缓冲区拷贝到用户空间，绕了一大圈。

更正式一点的说法是，mmap是 memory mapping 的缩写，它提供了一种将文件或者设备区域映射到进程地址空间的方法。这个映射建立之后，进程就可以通过访问内存地址来读写文件或者设备，操作系统会负责处理底层的I/O操作。

第二幕：mmap 的基本用法——小试牛刀

光说不练假把式，咱们先来个简单的例子，看看mmap是怎么用的。

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

int main() {
    const char* filename = "test.txt";
    const char* message = "Hello, mmap!";
    size_t len = strlen(message);
    int fd;
    void* map;

    // 1. 创建或者打开文件
    fd = open(filename, O_RDWR | O_CREAT, 0666);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    // 2. 调整文件大小，确保有足够的空间容纳数据
    if (ftruncate(fd, len) == -1) {
        perror("ftruncate");
        close(fd);
        return 1;
    }

    // 3. 使用 mmap 建立映射
    map = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (map == MAP_FAILED) {
        perror("mmap");
        close(fd);
        return 1;
    }

    // 4. 通过映射的地址写入数据
    memcpy(map, message, len);

    // 5. 同步数据到磁盘 (可选，但很重要!)
    if (msync(map, len, MS_SYNC) == -1) {
        perror("msync");
    }

    // 6. 解除映射
    if (munmap(map, len) == -1) {
        perror("munmap");
    }

    // 7. 关闭文件
    close(fd);

    std::cout << "Data written to file using mmap!" << std::endl;

    return 0;
}

这段代码做了这么几件事：

1. 打开文件： 使用 open 函数打开一个文件，如果文件不存在就创建它。
2. 调整文件大小： 使用 ftruncate 函数调整文件的大小，确保有足够的空间来存储我们要写入的数据。

3. 建立映射： 使用 mmap 函数建立文件和内存之间的映射。

   • NULL: 让系统自动选择映射的地址。
   • len: 映射的长度，也就是文件的大小。
   • PROT_READ | PROT_WRITE: 指定映射区域的权限，这里是可读可写。
   • MAP_SHARED: 指定映射类型，这里是共享映射，意味着对映射区域的修改会同步到磁盘上的文件。
   • fd: 文件描述符，指定要映射的文件。
   • 0: 文件偏移量，从文件的哪个位置开始映射。
4. 写入数据： 使用 memcpy 函数将数据写入到映射的内存区域。
5. 同步数据： 使用 msync 函数将内存中的数据同步到磁盘。这个步骤非常重要，否则数据可能会丢失！
6. 解除映射： 使用 munmap 函数解除映射，释放资源。
7. 关闭文件： 使用 close 函数关闭文件。

mmap 的参数详解：

参数	含义
addr	建议的映射起始地址，通常设为 NULL，让系统自动选择。
length	映射的长度，必须是页大小的整数倍。
prot	映射区域的保护权限，可以是 PROT_READ (可读), PROT_WRITE (可写), PROT_EXEC (可执行), PROT_NONE (不可访问) 的组合。
flags	映射标志，控制映射的行为，常用的有 MAP_SHARED (共享映射) 和 MAP_PRIVATE (私有映射)。
fd	文件描述符，指定要映射的文件。
offset	文件偏移量，必须是页大小的整数倍，指定从文件的哪个位置开始映射。

MAP_SHARED vs MAP_PRIVATE：

• MAP_SHARED： 共享映射，对映射区域的修改会同步到磁盘上的文件，其他映射到同一个文件的进程也能看到这些修改。
• MAP_PRIVATE： 私有映射，对映射区域的修改不会同步到磁盘上的文件，其他映射到同一个文件的进程也看不到这些修改。 修改会触发写时复制 (copy-on-write)，为每个进程创建一个独立的副本。

第三幕：mmap 在高性能 I/O 中的应用——速度与激情

mmap 在高性能 I/O 领域可是个明星，它能显著提高I/O操作的效率，原因如下：

• 减少数据拷贝： 传统 I/O 需要在用户空间和内核空间之间进行多次数据拷贝，而 mmap 可以直接将文件映射到用户空间，避免了这些拷贝操作。
• 零拷贝 (Zero-Copy) 的基础： mmap 可以作为零拷贝技术的基础，例如，网络传输可以直接从文件映射的内存区域读取数据，而不需要将数据先拷贝到用户空间。
• 随机访问： mmap 允许对文件进行随机访问，就像访问内存数组一样，这对于需要频繁读写文件中不同位置的数据的场景非常有用。

一个更实际的例子：读取大文件

假设我们要读取一个非常大的文件，例如一个日志文件，传统的方式是使用 fread 或者 ifstream 一块一块地读取，而使用 mmap 可以一次性将整个文件映射到内存，然后直接访问。

#include <iostream>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>

int main() {
    const char* filename = "large_file.txt"; // 假设 large_file.txt 是一个很大的文件
    int fd;
    void* map;
    struct stat sb;

    // 1. 打开文件
    fd = open(filename, O_RDONLY);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    // 2. 获取文件大小
    if (fstat(fd, &sb) == -1) {
        perror("fstat");
        close(fd);
        return 1;
    }
    size_t filesize = sb.st_size;

    // 3. 建立映射
    map = mmap(NULL, filesize, PROT_READ, MAP_PRIVATE, fd, 0);
    if (map == MAP_FAILED) {
        perror("mmap");
        close(fd);
        return 1;
    }

    // 4. 直接访问映射的内存区域
    char* data = (char*)map;
    for (size_t i = 0; i < filesize; ++i) {
        // 在这里可以对 data[i] 进行处理，例如统计字符出现次数，查找特定模式等
        // 为了演示，我们简单地输出前 100 个字符
        if (i < 100) {
            std::cout << data[i];
        }
    }
    std::cout << std::endl;

    // 5. 解除映射
    if (munmap(map, filesize) == -1) {
        perror("munmap");
    }

    // 6. 关闭文件
    close(fd);

    return 0;
}

这个例子中，我们首先使用 fstat 函数获取文件的大小，然后使用 mmap 将整个文件映射到内存，最后直接通过指针访问映射的内存区域。 这样可以避免频繁的 read 系统调用，提高读取大文件的效率。

第四幕：mmap 在共享内存中的应用——你好，世界！

mmap 不仅仅可以用于文件 I/O，还可以用于实现进程间的共享内存。 通过将同一块物理内存映射到不同进程的地址空间，可以实现进程间高效的数据共享。

一个简单的共享内存例子：

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

int main() {
    const char* shared_memory_name = "/my_shared_memory"; // 共享内存的名字
    size_t shared_memory_size = 4096; // 共享内存的大小

    int fd;
    void* shared_memory;
    pid_t pid;

    // 1. 创建或者打开共享内存对象
    fd = shm_open(shared_memory_name, O_RDWR | O_CREAT, 0666);
    if (fd == -1) {
        perror("shm_open");
        return 1;
    }

    // 2. 调整共享内存对象的大小
    if (ftruncate(fd, shared_memory_size) == -1) {
        perror("ftruncate");
        close(fd);
        return 1;
    }

    // 3. 使用 mmap 建立映射
    shared_memory = mmap(NULL, shared_memory_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (shared_memory == MAP_FAILED) {
        perror("mmap");
        close(fd);
        return 1;
    }

    // 4. 关闭文件描述符，因为已经建立了映射
    close(fd);

    // 5. 创建子进程
    pid = fork();
    if (pid == -1) {
        perror("fork");
        munmap(shared_memory, shared_memory_size);
        shm_unlink(shared_memory_name); // 删除共享内存对象
        return 1;
    }

    if (pid == 0) {
        // 子进程
        const char* message = "Hello from child!";
        strcpy((char*)shared_memory, message);
        std::cout << "Child: Wrote '" << message << "' to shared memory." << std::endl;
    } else {
        // 父进程
        wait(NULL); // 等待子进程结束
        std::cout << "Parent: Read '" << (char*)shared_memory << "' from shared memory." << std::endl;

        // 清理资源
        munmap(shared_memory, shared_memory_size);
        shm_unlink(shared_memory_name); // 删除共享内存对象
    }

    return 0;
}

这个例子中，我们使用了 shm_open 函数来创建或者打开一个共享内存对象，然后使用 mmap 将这个共享内存对象映射到父进程和子进程的地址空间。 这样，父进程和子进程就可以通过读写映射的内存区域来进行数据共享。

需要注意的是：

• shm_open 函数： 用于创建或者打开一个共享内存对象，它返回一个文件描述符，可以像操作普通文件一样操作这个共享内存对象。
• shm_unlink 函数： 用于删除一个共享内存对象。 只有当所有映射到该共享内存对象的进程都解除映射之后，才能真正删除该对象。
• 同步问题： 在使用共享内存时，需要注意同步问题，避免多个进程同时读写同一块内存区域导致数据竞争。 可以使用互斥锁、信号量等同步机制来保护共享内存区域。

第五幕：mmap 的注意事项和常见坑

mmap 虽然强大，但也有些需要注意的地方，一不小心就会掉坑里。

• 页大小对齐： mmap 的长度和偏移量必须是系统页大小的整数倍。 可以使用 sysconf(_SC_PAGE_SIZE) 函数获取系统的页大小。

  #include <unistd.h>
  #include <iostream>
  
  int main() {
      long page_size = sysconf(_SC_PAGE_SIZE);
      std::cout << "System page size: " << page_size << std::endl;
      return 0;
  }

• msync 的重要性： MAP_SHARED 模式下，对映射区域的修改并不会立即同步到磁盘，需要使用 msync 函数手动同步。 否则，数据可能会在程序崩溃或者系统重启时丢失。

• 文件大小： 映射的长度不能超过文件的大小。 如果需要扩展文件的大小，需要使用 ftruncate 函数。

• 信号处理： 当访问 mmap 映射的区域发生错误时 (例如访问了超出文件大小的区域)，可能会收到 SIGBUS 信号。 需要注意处理这些信号，避免程序崩溃。

• 内存泄漏： 如果忘记使用 munmap 函数解除映射，会导致内存泄漏。

• 并发访问： 多个进程同时读写同一个 MAP_SHARED 映射区域时，需要使用同步机制 (例如互斥锁、信号量) 来保护数据的一致性。

第六幕：mmap 的优缺点总结

优点	缺点
减少数据拷贝，提高 I/O 效率	需要注意页大小对齐，否则会导致错误
支持随机访问，方便对文件中不同位置的数据进行读写	需要手动同步数据到磁盘 (msync)，否则数据可能会丢失
可以用于实现进程间的共享内存，方便进程间的数据共享	访问超出文件大小的区域或者发生其他错误时，可能会收到 SIGBUS 信号
可以作为零拷贝技术的基础，进一步提高 I/O 效率	如果忘记解除映射 (munmap)，会导致内存泄漏
代码简洁，易于理解	在多线程或者多进程环境下，需要注意同步问题，避免数据竞争

第七幕：总结与展望

mmap 是一个非常强大的工具，可以显著提高 I/O 效率，方便进程间的数据共享。 但是，使用 mmap 也需要注意一些细节，避免掉坑里。

希望今天的讲解能帮助你更好地理解和使用 mmap。 在实际开发中，可以根据具体的场景选择是否使用 mmap。 例如，对于需要频繁读写大文件的场景，或者需要在多个进程之间共享大量数据的场景，mmap 都是一个不错的选择。

今天的分享就到这里，谢谢大家！ 如果有任何问题，欢迎提问。