C++实现基于内存映射文件（mmap）的持久化数据结构：实现系统重启后的数据恢复

C++实现基于内存映射文件（mmap）的持久化数据结构：实现系统重启后的数据恢复

大家好，今天我们来探讨一个重要的话题：如何利用内存映射文件（mmap）在C++中实现持久化的数据结构，并确保系统重启后数据的完整恢复。 在许多应用场景中，我们都需要确保数据在系统崩溃或重启后不会丢失。传统的做法是将数据写入磁盘文件，但在需要频繁读写的情况下，这种方式会带来显著的性能瓶颈。 mmap 提供了一种高效的替代方案，它允许我们将文件内容直接映射到进程的虚拟地址空间，从而像操作内存一样操作文件，极大地提升了I/O效率。

1. mmap 的基本概念

mmap (memory mapping) 是一种将磁盘文件的一部分或全部映射到进程地址空间的方法。映射完成后，进程就可以像访问内存一样访问文件内容，而无需显式地进行 read 或 write 系统调用。

主要优点：

• 高效的 I/O 操作： 避免了数据在用户空间和内核空间之间的多次拷贝。
• 简化编程模型： 可以像操作内存一样操作文件，降低了编程复杂性。
• 共享内存： 允许多个进程共享同一块物理内存，实现进程间通信。

涉及到的关键函数（POSIX 标准）：

• mmap()：创建内存映射。
• munmap()：解除内存映射。
• msync()：将内存映射的内容同步到磁盘。
• ftruncate()：改变文件大小。

工作流程：

1. 调用 open() 打开文件。
2. 调用 ftruncate() 设置文件大小，如果是新文件。
3. 调用 mmap() 将文件映射到进程地址空间。
4. 通过指针操作映射区域，读写数据。
5. 调用 msync() 将修改同步到磁盘。
6. 调用 munmap() 解除映射。
7. 调用 close() 关闭文件。

2. 选择合适的数据结构

在实现持久化数据结构之前，我们需要选择适合 mmap 的数据结构。一些常见选择包括：

• 连续内存块： 简单数组、结构体数组等。易于管理，但可能存在碎片问题。
• 链表： 灵活，但需要额外的指针存储空间，且在 mmap 中需要谨慎处理指针的持久化。
• B树/B+树： 适合索引和查找，但实现较为复杂。

对于简单的场景，例如键值对存储，我们可以使用哈希表。 为了简化示例，我们选择连续内存块，实现一个简单的键值对存储，其中键和值都是整数。

3. C++ 实现：持久化键值对存储

接下来，我们用 C++ 代码实现一个基于 mmap 的持久化键值对存储。 为了保证程序的鲁棒性，需要考虑多种异常情况，如文件不存在、文件大小不匹配等。

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

// 定义键值对结构体
struct KeyValuePair {
    int key;
    int value;
};

// 定义存储管理类
class PersistentMap {
private:
    const char* filename;
    int fd;
    KeyValuePair* data;
    size_t capacity; // 容量
    size_t size;     // 已用大小

    // 默认容量
    static const size_t DEFAULT_CAPACITY = 1024;

public:
    // 构造函数
    PersistentMap(const char* filename, size_t initialCapacity = DEFAULT_CAPACITY) : filename(filename), fd(-1), data(nullptr), capacity(initialCapacity), size(0) {
        openFile();
        mapFile();
    }

    // 析构函数
    ~PersistentMap() {
        unmapFile();
        closeFile();
    }

private:
    // 打开文件
    void openFile() {
        fd = open(filename, O_RDWR | O_CREAT, 0666);
        if (fd == -1) {
            throw std::runtime_error("Failed to open file.");
        }
    }

    // 关闭文件
    void closeFile() {
        if (fd != -1) {
            close(fd);
            fd = -1;
        }
    }

    // 映射文件到内存
    void mapFile() {
        struct stat fileInfo;
        if (fstat(fd, &fileInfo) == -1) {
            throw std::runtime_error("Failed to get file information.");
        }

        // 检查文件大小是否足够
        if (fileInfo.st_size < capacity * sizeof(KeyValuePair)) {
            // 扩展文件大小
            if (ftruncate(fd, capacity * sizeof(KeyValuePair)) == -1) {
                throw std::runtime_error("Failed to truncate file.");
            }
        } else {
            // 如果文件已经存在且大小足够，则从文件大小推断容量
            capacity = fileInfo.st_size / sizeof(KeyValuePair);
        }

        data = static_cast<KeyValuePair*>(mmap(nullptr, capacity * sizeof(KeyValuePair), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
        if (data == MAP_FAILED) {
            throw std::runtime_error("Failed to map file.");
        }

        // 初始化 size，首次创建文件时 size 为 0, 否则从文件读取
        if (fileInfo.st_size == 0) {
            size = 0;
        } else {
            // 假设文件大小是 KeyValuePair 的整数倍，否则可能需要更复杂的处理
            size = capacity; // 初始化为最大容量，需要在put和remove操作时维护
        }

        // 检查是否需要初始化数据，可以加上一个标志位来判断
        // 这里简化处理，假设每次启动都需要初始化数据
        for (size_t i = 0; i < capacity; ++i) {
            data[i].key = -1; // 使用 -1 作为 key 未使用的标志
        }
    }

    // 解除文件映射
    void unmapFile() {
        if (data != nullptr) {
            msync(data, capacity * sizeof(KeyValuePair), MS_SYNC); // 同步数据到磁盘
            munmap(data, capacity * sizeof(KeyValuePair));
            data = nullptr;
        }
    }

public:
    // 插入键值对
    bool put(int key, int value) {
        for (size_t i = 0; i < capacity; ++i) {
            if (data[i].key == -1) {
                data[i].key = key;
                data[i].value = value;
                size++;
                return true;
            }
        }
        return false; // 空间已满
    }

    // 获取键对应的值
    bool get(int key, int& value) {
        for (size_t i = 0; i < capacity; ++i) {
            if (data[i].key == key) {
                value = data[i].value;
                return true;
            }
        }
        return false; // 未找到
    }

    // 删除键值对
    bool remove(int key) {
        for (size_t i = 0; i < capacity; ++i) {
            if (data[i].key == key) {
                data[i].key = -1; // 标记为空闲
                size--;
                return true;
            }
        }
        return false; // 未找到
    }

    // 打印所有键值对
    void printAll() {
        for (size_t i = 0; i < capacity; ++i) {
            if (data[i].key != -1) {
                std::cout << "Key: " << data[i].key << ", Value: " << data[i].value << std::endl;
            }
        }
    }

    // 获取当前存储的键值对数量
    size_t getSize() const {
        return size;
    }

    // 获取容量
    size_t getCapacity() const {
        return capacity;
    }

    // 扩容
    void resize(size_t newCapacity) {
        if (newCapacity <= capacity) {
            std::cerr << "New capacity must be greater than current capacity." << std::endl;
            return;
        }

        unmapFile();
        closeFile();

        capacity = newCapacity;
        openFile();
        mapFile();

        // 重新初始化，因为 mmap 可能会映射到不同的内存区域
        for (size_t i = 0; i < capacity; ++i) {
            data[i].key = -1;
        }
    }
};

int main() {
    const char* filename = "persistent_map.data";
    PersistentMap map(filename, 10); // 初始容量为10

    // 插入一些数据
    map.put(1, 100);
    map.put(2, 200);
    map.put(3, 300);

    std::cout << "Initial data:" << std::endl;
    map.printAll();

    // 从文件中恢复数据
    PersistentMap recoveredMap(filename, 20); // 可以尝试不同的容量

    std::cout << "nRecovered data:" << std::endl;
    recoveredMap.printAll();

    int value;
    if (recoveredMap.get(2, value)) {
        std::cout << "nValue for key 2: " << value << std::endl;
    } else {
        std::cout << "nKey 2 not found." << std::endl;
    }

    recoveredMap.remove(2);
    std::cout << "nAfter removing key 2:" << std::endl;
    recoveredMap.printAll();

    recoveredMap.resize(30);
    recoveredMap.put(4, 400);
    std::cout << "nAfter resize and adding key 4:" << std::endl;
    recoveredMap.printAll();

    return 0;
}

代码解释：

• KeyValuePair 结构体定义了键值对。
• PersistentMap 类封装了 mmap 的操作。
  • openFile()、closeFile()、mapFile()、unmapFile() 分别负责文件的打开、关闭、映射和解除映射。
  • put()、get()、remove() 提供键值对的插入、查找和删除功能。
  • filename 存储文件名。
  • fd 存储文件描述符。
  • data 是指向映射内存区域的指针。
  • capacity 和 size 分别表示容量和已用大小。
• 构造函数打开并映射文件，如果文件不存在则创建。
• 析构函数解除映射并关闭文件。
• msync() 用于将内存中的数据同步到磁盘，保证数据持久化。
• ftruncate() 用于设置文件大小，确保文件足够存储数据。
• 示例代码演示了如何使用 PersistentMap 进行键值对的存储和恢复。

编译运行：

使用 g++ 编译：

g++ -std=c++11 persistent_map.cpp -o persistent_map

运行程序：

./persistent_map

4. 错误处理和异常安全

在实际应用中，错误处理至关重要。 上面的代码已经包含了基本的错误处理，例如检查 open()、mmap()、ftruncate() 等函数的返回值。 但是，为了保证程序的健壮性，还需要考虑更多的情况：

• 文件损坏： 如果文件被意外损坏，可能导致 mmap() 失败。 可以添加校验和或其他完整性检查机制。
• 磁盘空间不足： ftruncate() 可能因为磁盘空间不足而失败。
• 并发访问： 如果多个进程同时访问同一个文件，需要使用锁机制 (例如 flock()) 来保证数据一致性。
• 内存不足： mmap() 也可能因为内存不足而失败。

此外，还需要注意异常安全，确保在发生异常时，资源能够正确释放。 可以使用 RAII (Resource Acquisition Is Initialization) 来管理文件描述符和内存映射。

5. 高级特性和优化

除了基本功能，我们还可以考虑一些高级特性和优化：

• 动态扩容： 当存储空间不足时，可以动态扩展文件大小，并重新映射内存区域。 示例代码中已经包含了resize函数，可以进行动态扩容。注意扩容时需要处理好旧数据的迁移。
• 索引： 对于大型数据集，可以添加索引来加速查找。 可以使用 B 树或哈希表等数据结构作为索引。
• 事务： 为了保证数据一致性，可以使用事务机制。 这需要记录操作日志，并在系统重启后进行回滚或重做。
• 压缩： 对于存储空间有限的场景，可以对数据进行压缩。
• 多线程支持： 如果需要支持多线程并发访问，需要使用锁机制来保护共享数据。

6. 性能考量

mmap 通常比传统的 read/write 操作更高效，因为它避免了用户空间和内核空间之间的数据拷贝。 但是，也需要注意以下几点：

• 内存占用： mmap 会占用虚拟内存空间，即使文件内容没有被访问。
• 页面错误： 当访问未映射的内存页面时，会发生页面错误，这会带来一定的性能开销。 可以通过预读 (readahead) 来减少页面错误的发生。
• 同步开销： msync() 会将内存中的数据同步到磁盘，这会带来一定的性能开销。 可以根据实际需求选择合适的同步策略 (例如 MS_SYNC 或 MS_ASYNC)。

操作	描述	性能影响
mmap()	将文件映射到内存。	相对较快，但会占用虚拟内存空间。
munmap()	解除内存映射。	相对较快。
msync()	将内存中的数据同步到磁盘。	最关键的性能瓶颈。 MS_SYNC 会阻塞直到数据写入磁盘， MS_ASYNC 异步写入，但可能丢失数据。
ftruncate()	改变文件大小。	如果是扩展文件，可能会比较慢，因为需要分配磁盘空间。
页面错误	访问未映射的内存页面时发生。	导致性能下降，因为需要从磁盘加载数据到内存。
锁机制 (flock)	保护共享数据，防止并发访问冲突。	增加锁竞争会降低性能。

7. 替代方案

虽然 mmap 是一种高效的持久化数据结构实现方式，但并非所有场景都适用。 以下是一些替代方案：

• 数据库： 关系型数据库 (例如 MySQL、PostgreSQL) 或 NoSQL 数据库 (例如 MongoDB、Redis) 提供了更高级的数据管理功能，例如事务、索引、查询优化等。
• 键值存储： 像 LevelDB、RocksDB 这样的键值存储引擎，针对持久化存储进行了优化。
• 序列化： 将数据序列化成字节流，然后写入磁盘文件。 可以使用 Protocol Buffers、JSON 等序列化格式。

选择哪种方案取决于具体的应用需求。 如果需要高性能和低延迟，并且数据结构相对简单，mmap 是一个不错的选择。 如果需要更复杂的数据管理功能，或者需要处理大量数据，数据库或键值存储可能更合适。

8. 总结

今天，我们深入探讨了如何使用 mmap 在 C++ 中实现持久化的键值对存储。 我们学习了 mmap 的基本概念、C++ 代码实现、错误处理、高级特性和性能考量。 结合具体示例，对如何将内存映射文件应用于数据持久化有了更清晰的认识。

更多IT精英技术系列讲座，到智猿学院