C++中的Placement New与内存池：实现对象的生命周期与内存分配分离 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

好的，下面我将以讲座的模式，详细讲解C++中的Placement New与内存池，以及它们如何实现对象生命周期与内存分配的分离。

C++ Placement New 与内存池：对象生命周期与内存分配分离

大家好，今天我们来深入探讨C++中两个强大的特性：Placement New和内存池。它们在优化内存管理，尤其是需要频繁创建和销毁对象的场景下，发挥着重要作用。我们的核心目标是理解如何利用它们将对象的生命周期管理与内存分配过程解耦，从而提高程序的性能和可控性。

1. 内存分配的基础：new 与 delete

在C++中，最常见的内存分配方式是通过new和delete操作符。new负责分配内存并调用构造函数初始化对象，而delete则负责调用析构函数销毁对象并释放内存。

#include <iostream>

class MyClass {
public:
    MyClass(int value) : data(value) {
        std::cout << "Constructor called, data = " << data << std::endl;
    }
    ~MyClass() {
        std::cout << "Destructor called, data = " << data << std::endl;
    }
    int getData() const { return data; }
private:
    int data;
};

int main() {
    MyClass* obj = new MyClass(10);
    std::cout << "Data: " << obj->getData() << std::endl;
    delete obj; // Calls destructor and releases memory
    return 0;
}

在这个例子中，new MyClass(10)做了两件事：

分配足够的内存来存储MyClass对象。
调用MyClass的构造函数，使用参数10初始化对象。

delete obj也做了两件事：

调用MyClass的析构函数。
释放之前分配的内存。

虽然new和delete用起来很方便，但在某些情况下，它们的效率可能成为瓶颈。每次使用new和delete都可能涉及系统调用，这在频繁分配和释放小块内存时会带来显著的性能开销。此外，堆内存的碎片化也是一个需要考虑的问题。

2. Placement New 的概念与用法

Placement New允许我们在已分配的内存上构造对象，而不需要分配新的内存。它本质上是一个重载的new操作符，接受一个指向已分配内存的指针作为参数。

#include <iostream>
#include <new> // Required for placement new

class MyClass {
public:
    MyClass(int value) : data(value) {
        std::cout << "Constructor called, data = " << data << std::endl;
    }
    ~MyClass() {
        std::cout << "Destructor called, data = " << data << std::endl;
    }
    int getData() const { return data; }
private:
    int data;
};

int main() {
    // Allocate memory using malloc (or any other memory allocation method)
    void* buffer = malloc(sizeof(MyClass));
    if (buffer == nullptr) {
        std::cerr << "Memory allocation failed!" << std::endl;
        return 1;
    }

    // Use placement new to construct the object in the allocated memory
    MyClass* obj = new (buffer) MyClass(20);
    std::cout << "Data: " << obj->getData() << std::endl;

    // Explicitly call the destructor (important!)
    obj->~MyClass();

    // Release the memory (important!)
    free(buffer);

    return 0;
}

在这个例子中：

我们使用malloc分配了一块内存。注意：也可以使用自定义的内存分配器或者内存池来分配内存，这是Placement New的核心优势之一。
我们使用new (buffer) MyClass(20)在buffer指向的内存上构造了一个MyClass对象。注意：这里并没有分配新的内存，而是直接在已有的内存上调用构造函数。
最关键的一点：由于Placement New没有分配内存，因此delete obj不能直接使用，因为它会尝试释放buffer指向的内存，但buffer并不是通过new分配的。我们需要显式调用析构函数obj->~MyClass()来销毁对象。
最后，我们使用free(buffer)释放之前分配的内存。

Placement New 的优势：

减少内存分配开销： 避免频繁的new和delete操作，尤其是在需要大量创建和销毁小对象时。
内存预分配： 可以预先分配一块大的内存，然后反复使用Placement New在其中构造和销毁对象。
自定义内存管理： 可以使用自定义的内存分配器，例如内存池，来管理内存。
对象生命周期控制： 将对象的生命周期管理与内存分配解耦，可以更灵活地控制对象的创建和销毁。

Placement New 的注意事项：

显式调用析构函数： 必须显式调用析构函数来销毁对象。忘记调用析构函数会导致内存泄漏和资源泄露。
内存对齐： 确保分配的内存满足对象的对齐要求。
异常安全： 如果构造函数抛出异常，需要妥善处理已分配的内存，避免内存泄漏。

3. 内存池的概念与实现

内存池是一种内存管理技术，它预先分配一块大的连续内存块，然后将这块内存分割成若干个大小相同的块，用于存储特定类型的对象。当需要创建对象时，从内存池中取出一个空闲的块；当对象销毁时，将该块返回到内存池中。

内存池的优点：

提高内存分配速度： 避免了频繁的系统调用，内存分配速度更快。
减少内存碎片： 内存池中的内存块大小相同，可以有效减少内存碎片。
提高缓存命中率： 连续的内存块可以提高缓存命中率，从而提高程序的性能。

一个简单的内存池实现：

#include <iostream>
#include <vector>

template <typename T>
class MemoryPool {
public:
    MemoryPool(size_t size) : poolSize(size), freeBlocks(size) {
        pool = malloc(sizeof(T) * poolSize);
        if (pool == nullptr) {
            throw std::bad_alloc();
        }

        // Initialize the free list
        char* currentBlock = static_cast<char*>(pool);
        for (size_t i = 0; i < poolSize; ++i) {
            freeBlocks[i] = currentBlock;
            currentBlock += sizeof(T);
        }
    }

    ~MemoryPool() {
        free(pool);
    }

    T* allocate() {
        if (freeBlocks.empty()) {
            return nullptr; // Or throw an exception
        }

        char* block = freeBlocks.back();
        freeBlocks.pop_back();
        return reinterpret_cast<T*>(block);
    }

    void deallocate(T* ptr) {
        freeBlocks.push_back(reinterpret_cast<char*>(ptr));
    }

private:
    void* pool;
    size_t poolSize;
    std::vector<char*> freeBlocks;
};

class MyClass {
public:
    MyClass(int value) : data(value) {
        std::cout << "Constructor called, data = " << data << std::endl;
    }
    ~MyClass() {
        std::cout << "Destructor called, data = " << data << std::endl;
    }
    int getData() const { return data; }
private:
    int data;
};

int main() {
    MemoryPool<MyClass> pool(10); // Create a memory pool for 10 MyClass objects

    MyClass* obj1 = new (pool.allocate()) MyClass(30); // Placement new with memory from the pool
    if (obj1 == nullptr) {
        std::cerr << "Memory allocation failed!" << std::endl;
        return 1;
    }

    std::cout << "Data: " << obj1->getData() << std::endl;

    MyClass* obj2 = new (pool.allocate()) MyClass(40); // Placement new with memory from the pool
        if (obj2 == nullptr) {
        std::cerr << "Memory allocation failed!" << std::endl;
        //Need to deallocate obj1 to avoid resource leak
        obj1->~MyClass();
        pool.deallocate(obj1);
        return 1;
    }
    std::cout << "Data: " << obj2->getData() << std::endl;

    obj1->~MyClass(); // Explicitly call the destructor
    pool.deallocate(obj1); // Return the memory to the pool

    obj2->~MyClass(); // Explicitly call the destructor
    pool.deallocate(obj2); // Return the memory to the pool
    return 0;
}

在这个例子中：

MemoryPool类预先分配了一块内存，并将其分割成若干个MyClass对象大小的块。
allocate方法从内存池中取出一个空闲的块，并返回指向该块的指针。
deallocate方法将一个块返回到内存池中。
在main函数中，我们使用Placement New在从内存池中分配的内存上构造MyClass对象。
我们显式调用析构函数，并将内存返回到内存池中。

4. 内存池的变体和更高级的实现

上面的例子展示了一个最简单的内存池实现。实际应用中，内存池可能会更加复杂，包含以下特性：

不同大小的内存块： 可以根据对象的大小分配不同大小的内存块，以提高内存利用率。
多线程支持： 需要考虑线程安全问题，可以使用锁或其他同步机制来保护内存池。
自动增长： 当内存池中的内存不足时，可以自动扩展内存池的大小。
垃圾回收： 可以实现简单的垃圾回收机制，自动回收不再使用的内存块。

5.Placement New 与内存池结合的优势

将Placement New和内存池结合使用，可以充分发挥两者的优势，实现更高效的内存管理。

减少内存分配开销： 内存池预先分配内存，Placement New避免了频繁的系统调用。
提高内存利用率： 内存池可以管理内存碎片，提高内存利用率。
对象生命周期控制： Placement New允许我们精确控制对象的创建和销毁。
自定义内存管理： 可以根据应用的需求定制内存池，例如使用不同的分配策略或垃圾回收机制。

6.何时使用 Placement New 和内存池？

Placement New和内存池并不是万能的。在以下情况下，它们可能更有用：

频繁创建和销毁小对象： 例如，游戏引擎中的粒子、网络服务器中的连接对象等。
对性能要求较高的应用： 例如，实时系统、嵌入式系统等。
需要自定义内存管理的应用： 例如，需要控制内存分配策略或实现垃圾回收的应用。

7. 实例演示：游戏引擎中的粒子系统

在游戏引擎中，粒子系统通常需要频繁创建和销毁大量的粒子对象。使用Placement New和内存池可以显著提高粒子系统的性能。

#include <iostream>
#include <vector>
#include <new> // Required for placement new

// Simplified Particle class
class Particle {
public:
    Particle(float x, float y, float life) : x_(x), y_(y), life_(life) {
        //std::cout << "Particle Constructor called" << std::endl;
    }
    ~Particle() {
       // std::cout << "Particle Destructor called" << std::endl;
    }

    void update(float deltaTime) {
        life_ -= deltaTime;
        // Update particle position, velocity, etc.
    }

    bool isAlive() const {
        return life_ > 0;
    }
private:
    float x_;
    float y_;
    float life_;
};

// Custom Memory Pool for Particles
class ParticlePool {
public:
    ParticlePool(size_t capacity) : capacity_(capacity), particles_(capacity) {
        data_ = malloc(sizeof(Particle) * capacity_);
        if (data_ == nullptr) {
            throw std::bad_alloc();
        }

        //Pre-allocate all the particles
        char* currentBlock = static_cast<char*>(data_);
        for (size_t i = 0; i < capacity_; ++i) {
            particles_[i] = currentBlock;
            currentBlock += sizeof(Particle);
        }

        //Initialize the freelist with all particles
        freelist_ = particles_;
        nextAvailable_ = 0;
    }

    ~ParticlePool() {
        // Explicitly destroy all constructed particles before freeing the memory
        for (size_t i = 0; i < capacity_; ++i) {
            if (isConstructed_[i]) {
                reinterpret_cast<Particle*>(particles_[i])->~Particle();
            }
        }
        free(data_);
    }

    Particle* createParticle(float x, float y, float life) {
        if (nextAvailable_ >= capacity_) {
            return nullptr; // Pool is full
        }

        void* particlePtr = freelist_[nextAvailable_];
        nextAvailable_++;
        Particle* particle = new (particlePtr) Particle(x, y, life);
        isConstructed_[nextAvailable_-1] = true;
        return particle;
    }

    void destroyParticle(Particle* particle) {
        // Find the index of the particle in the particle array
        size_t index = -1;
        for(size_t i = 0; i < capacity_; ++i){
            if(particles_[i] == reinterpret_cast<char*>(particle))
            {
                index = i;
                break;
            }
        }

        if(index == -1){
            return; //not managed by this pool
        }

        //Explicitly call the destructor
        particle->~Particle();
        isConstructed_[index] = false;

        // Move the destroyed particle to the end of the freelist
        nextAvailable_--;
        freelist_[nextAvailable_] = reinterpret_cast<char*>(particle);
    }

private:
    void* data_;
    size_t capacity_;
    std::vector<char*> particles_;
    char** freelist_; // Array of pointers to free particles
    size_t nextAvailable_;
    bool isConstructed_[1000] = {false}; //Track constructed objects
};

int main() {
    ParticlePool particlePool(1000);

    // Simulate particle creation and destruction
    std::vector<Particle*> activeParticles;
    for (int i = 0; i < 500; ++i) {
        Particle* particle = particlePool.createParticle(i * 0.1f, i * 0.2f, 5.0f);
        if (particle != nullptr) {
            activeParticles.push_back(particle);
        } else {
            std::cout << "Particle pool is full!" << std::endl;
            break;
        }
    }

    // Simulate particle update and destruction
    float deltaTime = 0.1f;
    for (auto it = activeParticles.begin(); it != activeParticles.end(); ) {
        (*it)->update(deltaTime);
        if (!(*it)->isAlive()) {
            particlePool.destroyParticle(*it);
            it = activeParticles.erase(it);
        } else {
            ++it;
        }
    }

    std::cout << "Simulation finished." << std::endl;
    return 0;
}

在这个例子中，ParticlePool类使用Placement New在预先分配的内存上创建和销毁Particle对象，避免了频繁的new和delete操作，从而提高了粒子系统的性能。需要注意 isConstructed_数组，用于在析构函数中，只析构已经构造的对象，防止多次析构同一块内存造成错误。

8. 总结：对象生命周期与内存分配分离

Placement New和内存池是C++中强大的工具，它们可以将对象的生命周期管理与内存分配过程解耦，提高程序的性能和可控性。在需要频繁创建和销毁对象的场景下，它们可以显著减少内存分配开销，提高内存利用率。但是，使用它们需要谨慎，需要显式调用析构函数，并注意内存对齐和异常安全等问题。

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

发表回复 取消回复

发表回复取消回复