目录
一、对象池简介
1.1 池化技术
1.2 什么是对象池
1.3 对象池分配策略
二、C++ new和delete运算符重载
三、实现一个对象池框架
3.1 策略接口
四、实现几种对象池的分配策略
4.1 数组策略
4.2 堆策略
编辑
4.3 栈策略
4.4 区块策略
一、对象池简介
1.1 池化技术
线程池、连接池、内存池
池化技术共同点
提前创建资源，以备不时之需时重复利用，极致的提升性能。
由于在实际应用里分配内存、创建进程、线程，都会涉及到一些系统调用，系统调用需要导致程序从用户态切换到内核态，是非常耗时的操作。因此，当程序中需要频繁的进行内存申请释放，进程、线程创建销毁等操作时，通常会使用内存池、进程池、线程池等技术来提升程序的性能。
1.2 什么是对象池
对象池简介
对象池的实现和内存池的实现原理很像:都是-开始申请大内存空间, 然后把大内存分配成小内存空间，当需要使用的时候直接分配使用,不再向系统申请内存空间，也不直接释放内存空间。使用完之后都是放回池子里。
注意
对象池其实就是一种特殊的内存池，仅分配固定大小的内存。
1.3 对象池分配策略
● 基于数组的策略
● 基于堆的策略
● 基于栈的策略
● 基于区块的策略
课程里我们会实现以上几种对象池的分配策略，从最简单的数组策略到比较复杂的区块策略。每种策略都有各自的特点和适用场景。
二、C++ new和delete运算符重载
class A
{
public:void * operator new(size_t n){std::cout << "A new" << std::endl; return ::malloc(n);}void operator delete(void * p){std::cout << "A delete" << std::endl;::free(p);}
};
三、实现一个对象池框架
3.1 策略接口
template <typename T>
class Allocator {
public:virtual T * allocate() = 0;virtual void deallocate(T * p) = 0;
};策略接口函数：
allocate：分配内存
deallocate：回收内存
现在创建和析构对象不需要用new和free了，而是用对象池的创建和析构函数。
// a.h#pragma once
#include <iostream>
#include "object_pool.h"
#include "malloc_allocator.h"using namespace huan::object;class A
{
private:typedef ObjectPool<A, MallocAllocator<A>> ObjectPool;static ObjectPool pool;
public:A(){std::cout << "A construct" << std::endl;}~A(){std::cout << "A destruct" << std::endl;}void * operator new(size_t n){std:: cout << "A new" << std::endl;return pool.allocate(n);}void operator delete(void * p){std::cout << "A delete" << std::endl;pool.deallocate(p);}
};A::ObjectPool A::pool;// object_pool.h#pragma once#include <stdexcept>namespace huan
{namespace object{template <typename T, typename Allocator>class ObjectPool{public:ObjectPool() = default;~ObjectPool() = default;void * allocate(size_t n){if (sizeof(T) != n)throw std::bad_alloc();return m_allocator.allocate();}void deallocate(void * p){m_allocator.deallocate(static_cast<T *>(p));}private:Allocator m_allocator;};}
}// malloc_allocator.h#pragma once#include "allocator.h"namespace huan
{namespace object{template <typename T>class MallocAllocator : public Allocator<T>{public:MallocAllocator() = default;~MallocAllocator() = default;virtual T * allocate(){auto p = ::malloc(sizeof(T));return reinterpret_cast<T *>(p);}virtual void deallocate(T * p){::free(p);}};}
}// allocator.h#pragma oncenamespace huan
{namespace object{template <typename T>class Allocator{public:virtual T * allocate() = 0;virtual void deallocate(T * p) = 0;};}
}四、实现几种对象池的分配策略
4.1 数组策略
#include <src/a.h>int main()
{A * arr[max_size] = { nullptr };for (int i = 0; i < max_size; i++){A * a = new A();arr[i] = a;}for (int i = 0; i < max_size; i++){delete arr[i];}return 0;
}#pragma once#include "allocator.h"namespace huan
{namespace object{template <typename T, int N>class ArrayAllocator : public Allocator<T>{public:ArrayAllocator(){for (int i = 0; i < N; i++){m_used[i] = false;}}~ArrayAllocator() = default;virtual T * allocate(){for (int i = 0; i < N; i++){if (!m_used[i]){m_used[i] = true;return reinterpret_cast<T *>(&m_data[sizeof(T) * i]);}}// 如果没找到throw std::bad_alloc();}virtual void deallocate(T * p){auto i = ((unsigned char *)p - m_data) / sizeof(T);m_used[i] = false;}private:unsigned char m_data[sizeof(T) * N];bool m_used[N];};}
}注意：基于数组的时间复杂度高 O(n)
4.2 堆策略
使用大根堆，heap第一个位置总是空闲的。在插入一个对象后，堆会重新把一个没有使用的位置放到第一位
// heap_allocator.h#include <algorithm>
#include "allocator.h"namespace huan
{namespace object{template <typename T, int N>class HeapAllocator : public Allocator<T>{public:enum State{FREE = 1,USED = 0,};struct Entry{State state; // 状态T * p; // 对象指针bool operator < (const Entry & other) const{return state < other.state;}};HeapAllocator(){m_available = N;for (int i = 0; i < N; i++){m_entry[i].state = FREE; // 未使用m_entry[i].p = reinterpret_cast<T *>(&m_data[sizeof(T) * i]);}// 调用生成大堆的算法std::make_heap(m_entry, m_entry + N);}~HeapAllocator() = default;virtual T * allocate(){if (m_available <= 0)throw std::bad_alloc();Entry e = m_entry[0];std::pop_heap(m_entry, m_entry + N);m_available--;m_entry[m_available].state = USED;m_entry[m_available].p = nullptr;return e.p;}virtual void deallocate(T * p){if (p == nullptr || m_available >= N)return;m_entry[m_available].state = FREE;m_entry[m_available].p = reinterpret_cast<T *>(p);m_available++;std::push_heap(m_entry, m_entry + N);}private:unsigned char m_data[sizeof(T) * N];Entry m_entry[N];int m_available;};}
}时间复杂度 O(log n)
