c++对象池简单实现

#include <list>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>


using namespace std;

template<typename ItemPointer>
class MemoryPool {
public:
    std::list<ItemPointer> q;
    using Item_type = typename std::remove_pointer<typename std::decay<ItemPointer>::type>::type;

    ItemPointer CheckOut() {
        ItemPointer item = nullptr;
        if (q.empty()) {
            item = new Item_type;
        } else {
            item = q.front();
            q.pop();
        }
        return item;
    }

    void CheckIn(ItemPointer item) {
        q.push(item);
    }
};

template<typename ItemPointer>
class MultiThreadPool {
private:
    static pthread_key_t key;
    static pthread_once_t once;

    static void init_pthread_key() {
        pthread_key_create(&key, nullptr);
    }
public:
    static MemoryPool<ItemPointer>* getPool() {
        pthread_once(&once, init_pthread_key);
        auto data = (MemoryPool<ItemPointer>*)pthread_getspecific(key);
        if (!data) {
            data = new MemoryPool<ItemPointer>;
            pthread_setspecific(key, data);
        }
        return data;
    }

    static ItemPointer CheckOut() {
        return getPool()->CheckOut();
    }

    static void CheckIn(ItemPointer item) {
        getPool()->CheckIn(item);
    }
};

/*
多线程对象池
*/
template<typename ItemPointer>
pthread_key_t MultiThreadPool<ItemPointer>::key;
template<typename ItemPointer>
pthread_once_t MultiThreadPool<ItemPointer>::once;

class LoggerItem {
public:
    char* buffer;
    static constexpr size_t max_log_size = 2048;

    LoggerItem() {
        buffer = new char[max_log_size];
    }

    ~LoggerItem() {
        delete buffer;
        buffer = nullptr;
    }
};

int main() {
    MultiThreadPool<LoggerItem*> mp;
    auto data = mp.CheckOut();
    data->buffer[0] = '0';
    mp.CheckIn(data);
}