C++ `std::pmr::synchronized_pool_resource`：线程安全的内存池资源管理

哈喽，各位好！今天咱们聊聊 C++ 里一个挺酷的家伙，std::pmr::synchronized_pool_resource。这玩意儿听着名字挺长，但其实就是个线程安全的内存池资源管理器。 简单来说，它能帮你更高效、更安全地管理内存，尤其是在多线程环境下。

什么是内存池？为什么要用它？

想象一下，你开了一家餐馆，客人来了就现做菜。每次做菜都要跑到菜市场买菜，是不是效率很低？内存池就像你提前把菜买好、洗好、切好，放在厨房里，客人来了直接从厨房拿，省去了很多跑腿的时间。

在程序里，内存的分配和释放是很频繁的操作。每次都向操作系统申请内存 (比如用 new)，操作系统都要费劲地找一块空闲的内存给你，用完了再还回去。这个过程很慢，而且容易产生内存碎片。

内存池就是预先分配一大块内存，然后自己管理这块内存。当你需要内存时，直接从内存池里取一块给你；用完了再还给内存池，而不是还给操作系统。这样就避免了频繁地向操作系统申请和释放内存，提高了效率，也减少了内存碎片。

std::pmr 是个啥？

std::pmr (Polymorphic Memory Resources) 是 C++17 引入的一个标准库特性，它提供了一种更灵活的内存管理方式。简单来说，它允许你使用不同的内存分配策略，而不用修改你的代码。synchronized_pool_resource 就是 std::pmr 提供的一种内存资源。

synchronized_pool_resource 的特点

• 线程安全： 这是它最大的特点。多个线程可以同时从同一个 synchronized_pool_resource 对象分配和释放内存，而不用担心数据竞争。
• 基于池化： 它使用内存池来管理内存，提高了分配和释放的效率。
• 可定制： 你可以指定内存池的大小、分配策略等。
• 易于使用： 它是标准库的一部分，使用起来很方便。

怎么用 synchronized_pool_resource？

首先，需要包含头文件 <memory_resource>：

#include <memory_resource>
#include <vector>
#include <iostream>
#include <thread>
#include <mutex>

using namespace std;
using namespace std::pmr;

然后，创建一个 synchronized_pool_resource 对象：

synchronized_pool_resource pool;

现在，你可以用这个 pool 对象来分配内存了。 std::pmr 设计的巧妙之处在于，它通过 std::pmr::polymorphic_allocator 来使用内存资源。

polymorphic_allocator<int> alloc(&pool); // 使用 pool 作为内存资源

有了 alloc，你就可以用它来创建容器了。例如，创建一个 std::pmr::vector：

vector<int> vec(alloc); // 使用 pool 分配 vector 的内存

或者，直接用 new 操作符分配内存，然后用 pool 来释放内存：

int* ptr = new (pool) int(10); // 在 pool 中分配一个 int
// ... 使用 ptr ...
pool.deallocate(ptr, sizeof(int)); // 将 ptr 指向的内存还给 pool (注意这里需要自己计算大小)

一个简单的例子

#include <memory_resource>
#include <vector>
#include <iostream>

using namespace std;
using namespace std::pmr;

int main() {
    synchronized_pool_resource pool;
    polymorphic_allocator<int> alloc(&pool);

    vector<int> vec(alloc);
    for (int i = 0; i < 10; ++i) {
        vec.push_back(i);
    }

    for (int i : vec) {
        cout << i << " ";
    }
    cout << endl;

    return 0;
}

这个例子创建了一个 synchronized_pool_resource 对象，然后用它来分配一个 std::pmr::vector 的内存。 std::pmr::vector 和普通的 std::vector 用法基本一样，只是构造函数需要传入一个 polymorphic_allocator 对象。

多线程的例子

这才是 synchronized_pool_resource 真正发挥作用的地方。

#include <memory_resource>
#include <vector>
#include <iostream>
#include <thread>
#include <mutex>

using namespace std;
using namespace std::pmr;

const int NUM_THREADS = 4;
const int NUM_ELEMENTS = 1000;

synchronized_pool_resource pool;
mutex cout_mutex; // 保护 cout 的互斥锁

void worker_thread(int thread_id) {
    polymorphic_allocator<int> alloc(&pool);
    vector<int> vec(alloc);

    for (int i = 0; i < NUM_ELEMENTS; ++i) {
        vec.push_back(thread_id * NUM_ELEMENTS + i);
    }

    {
        lock_guard<mutex> lock(cout_mutex); // 保护 cout
        cout << "Thread " << thread_id << ": Vector size = " << vec.size() << endl;
    }
}

int main() {
    thread threads[NUM_THREADS];

    for (int i = 0; i < NUM_THREADS; ++i) {
        threads[i] = thread(worker_thread, i);
    }

    for (int i = 0; i < NUM_THREADS; ++i) {
        threads[i].join();
    }

    cout << "All threads finished." << endl;

    return 0;
}

在这个例子中，我们创建了多个线程，每个线程都使用同一个 synchronized_pool_resource 对象来分配 std::pmr::vector 的内存。由于 synchronized_pool_resource 是线程安全的，所以我们不需要额外的同步机制来保护内存分配。

synchronized_pool_resource 的构造函数

synchronized_pool_resource 有几个构造函数，可以让你定制内存池的行为：

• synchronized_pool_resource(memory_resource* upstream): 使用指定的 upstream 内存资源作为后备。如果 synchronized_pool_resource 无法满足内存分配请求，它会委托给 upstream。
• synchronized_pool_resource(size_t block_size, memory_resource* upstream): 指定每个内存块的大小。
• synchronized_pool_resource(size_t block_size, size_t max_blocks_per_chunk, memory_resource* upstream): 指定每个内存块的大小和每个 chunk 的最大块数。

upstream 内存资源

synchronized_pool_resource 需要一个 upstream 内存资源。当 synchronized_pool_resource 自身的内存池耗尽时，它会委托给 upstream 来分配内存。常用的 upstream 内存资源有：

• std::pmr::new_delete_resource(): 使用 new 和 delete 来分配和释放内存。这是默认的 upstream。
• std::pmr::null_memory_resource(): 不分配任何内存。如果 synchronized_pool_resource 无法满足内存分配请求，它会抛出异常。
• 自定义的 memory_resource。

monotonic_buffer_resource 和 synchronized_pool_resource 的区别

monotonic_buffer_resource 也是 std::pmr 提供的一种内存资源，它和 synchronized_pool_resource 有一些区别：

特性	monotonic_buffer_resource	synchronized_pool_resource
线程安全	否	是
内存分配方式	单调递增	池化
内存释放	只能一次性释放所有内存	可以单独释放每个内存块
适用场景	临时性数据结构	需要频繁分配和释放内存的场景

简单来说，monotonic_buffer_resource 适用于单线程环境，并且只需要一次性分配和释放内存的场景。而 synchronized_pool_resource 适用于多线程环境，并且需要频繁分配和释放内存的场景。

何时使用 synchronized_pool_resource？

• 多线程环境： 这是最主要的场景。如果你需要在多个线程中共享内存分配，synchronized_pool_resource 可以提供线程安全的内存管理。
• 需要提高内存分配效率的场景： 如果你的程序需要频繁地分配和释放内存，synchronized_pool_resource 可以通过池化来提高效率。
• 需要减少内存碎片的场景： synchronized_pool_resource 可以通过池化来减少内存碎片。

注意事项

• 内存泄漏： 如果你使用 synchronized_pool_resource 直接分配内存 (比如用 new (pool))，你需要自己负责释放内存。如果忘记释放，就会导致内存泄漏。
• 过度分配： synchronized_pool_resource 会预先分配一大块内存。如果你的程序实际使用的内存很少，就会造成内存浪费。
• 异常安全： 如果在使用 synchronized_pool_resource 分配内存时发生异常，可能会导致内存池的状态不一致。你需要小心处理异常，确保内存池的状态是正确的。

高级用法：自定义内存分配策略

你可以通过自定义 memory_resource 来实现自己的内存分配策略。例如，你可以创建一个基于 mmap 的内存资源，或者一个基于 GPU 内存的内存资源。

要自定义 memory_resource，你需要继承 std::pmr::memory_resource 类，并实现以下几个虚函数：

• void* do_allocate(size_t bytes, size_t alignment): 分配指定大小和对齐方式的内存。
• void do_deallocate(void* p, size_t bytes, size_t alignment): 释放指定的内存。
• bool do_is_equal(const memory_resource& other) const noexcept: 判断两个 memory_resource 对象是否相等。

一个自定义 memory_resource 的例子

#include <memory_resource>
#include <iostream>

using namespace std;
using namespace std::pmr;

class MyMemoryResource : public memory_resource {
public:
    MyMemoryResource(size_t size) : size_(size), buffer_(new char[size]), offset_(0) {}

    ~MyMemoryResource() {
        delete[] buffer_;
    }

protected:
    void* do_allocate(size_t bytes, size_t alignment) override {
        // 简单的分配器，没有考虑对齐
        if (offset_ + bytes > size_) {
            return nullptr; // 或者抛出异常
        }

        void* ptr = buffer_ + offset_;
        offset_ += bytes;
        return ptr;
    }

    void do_deallocate(void* p, size_t bytes, size_t alignment) override {
        // 简单的分配器，不支持单独释放内存
        // 在析构函数中一次性释放所有内存
        cout << "Deallocate called, but doing nothing." << endl;
    }

    bool do_is_equal(const memory_resource& other) const noexcept override {
        return this == &other;
    }

private:
    size_t size_;
    char* buffer_;
    size_t offset_;
};

int main() {
    MyMemoryResource my_resource(1024);
    polymorphic_allocator<int> alloc(&my_resource);

    int* ptr = alloc.allocate(1); // 分配一个 int
    *ptr = 42;

    cout << *ptr << endl;

    alloc.deallocate(ptr, 1); // 实际上什么也没做

    return 0;
}

这个例子创建了一个简单的 memory_resource，它使用一个固定大小的缓冲区来分配内存。 do_allocate 函数只是简单地将 offset_ 增加 bytes，然后返回缓冲区的指针。 do_deallocate 函数什么也不做，因为这个简单的分配器不支持单独释放内存。

总结

std::pmr::synchronized_pool_resource 是一个强大的工具，可以帮助你更高效、更安全地管理内存，尤其是在多线程环境下。 但是，你需要了解它的特点和限制，才能正确地使用它。 记住，没有银弹，选择合适的工具取决于你的具体需求。

希望今天的讲解对大家有所帮助！下次再见！