1.效率问题：如果我们直接向系统申请内存，当我们需要频繁的申请释放内存时，就需要频繁的与系统层产生交互，多次切换用户态和内核态，而用户态和内核态之间的切换的消耗是非常大的，因此申请内存的消耗就会很大，程序效率也就随之降低了。
2.内存碎片问题：如果我们频繁的申请和释放小块的内存，系统的内存就会因此被碎片化，虽然总的内存被占用并不多，但是却没有了连续的大块内存，这个时候如果我们需要使用大内存的空间时，就无法申请了。
现在大部分的开发环境都是多核多线程，在申请内存的场景下，必然存在激烈的锁竞争问题。要实现一个高并发的内存池，必须要考虑以下几个问题：
主要由三部分组成：
线程缓存，是每一个线程独有的，用于小于64k的内存的分配，线程从这里申请内存不需要加锁，每个线程独享一个cache，这也就是这个并发高效的地方中心缓存是所有线程所共享，thread cache是按需要从Central cache中获取的对象。 Central cache周期性的回收thread cache中的对象，避免一个线程占用了太多的内存，而其他线程的内存吃紧。达到内存分配在多个线程中更均衡的按需调度的目的。Central cache是存在竞争的，所以从这里取内存对象是需要加锁页缓存是在Central cache缓存上面的一层缓存，存储的内存是以页为单位存储及分配 的，Central cache没有内存对象(Span)时，从Page cache分配出一定数量的page，并切割成定长大小的小块内存，分配给Central cache。Page cache会回收Central cache满足条件的Span(使用计数为0)对象，并且合并相邻的页，组成更大的页，缓解内存碎片的问题。**怎么实现每个线程都拥有自己唯一的线程缓存？**⭐⭐⭐
为了避免加锁带来的效率，在Thread Cache中使用thread local storageTLS保存每个线程本地的ThreadCache的指针，这样Thread Cache在申请释放内存时是不需要锁的，因为每一个线程都拥有了自己唯一的全局变量。
class ThreadCache
{
public:
void* Allocate(size_t size);//分配内存
void Deallocate(void* ptr, size_t size);//释放内存
//从中心缓存中获取内存对象
void* FetchFromCentralCache(size_t index, size_t size);
//当自由链表中的对象超过一次分配给threadcache的数量，则开始回收
void ListTooLong(FreeList* freelist, size_t byte);
private:
FreeList _freelist[NLISTS];// 创建了一个自由链表数组
};
从ThreadCache申请内存：
当内存申请size<=64时2在ThreadCache中申请，计算size在自由链表中的位置，如果自由链表中有内存对象直接从FreeList[i]中pop一下对象，时间复杂度时O(1)，且没有锁竞争；当Freelist[i]中没有对象时则批量从CentralCache中获取一定数量的对象，插入到自由链表并返回一个对象（剩余的n-1个对象插入到自由链表并返回一 个对象）
向ThreadCache释放内存：
当释放内存小于64k时将内存释放回Thread Cache， 计算size在自由链表中的位置，将对象Push到FreeList[i]； 当链表的长度过长， 也就是超过一次最大限制数目时则回收一部分内存对象到Central Cache。
中心缓存要实现为单例模式，保证全局只有一份实例
注意：由span对象划分出去的内存块和这个span对象是有归属关系的，所以由thread cache归还释放某个内存(比如16bytes)应该归还到central cache的16bytes部分的他所归属的那个span对象上
那么， 怎么才能将Thread Cache中的内存对象还给它原来的span呢？
答：可以在Page Cache中维护一个页号到span的映射。当Page Cache给Central Cache分配一个span时，将这个映射更新到unordered_map中去，这样的话在central cache中的span对象下的内存块都是属于某个页的 也就有他的页号,，同一个span切出来的内存块PageID都和span的PageID相同，这样就能很好的找出某个内存块属于哪一个span了。
//设计成单例模式
class CentralCache
{
public:
static CentralCache* Getinstence()
{
return &_inst;
}
//从page cache获取一个span
Span* GetOneSpan(SpanList& spanlist, size_t byte_size);
//从中心缓存获取一定数量的对象给threa cache
size_t FetchRangeObj(void*& start, void*& end, size_t n, size_t byte_size);
//将一定数量的对象释放给span跨度
void ReleaseListToSpans(void* start, size_t size);
private:
SpanList _spanlist[NLISTS];
private:
CentralCache(){}//声明不实现，防止默认构造，自己创建
CentralCache(CentralCache&) = delete;
static CentralCache _inst;
};
Page cache是一个以页为单位的span自由链表；为了保证全局只有唯一的Page cache，这个类可以被设计成了单例模式，本单例模式采用饿汉模式
class PageCache
{
public:
static PageCache* GetInstence()
{
return &_inst;
}
Span* AllocBigPageObj(size_t size);
void FreeBigPageObj(void* ptr, Span* span);
Span* _NewSpan(size_t n);
Span* NewSpan(size_t n);//获取的是以页为单位
//获取从对象到span的映射
Span* MapObjectToSpan(void* obj);
//释放空间span回到PageCache，并合并相邻的span
void ReleaseSpanToPageCache(Span* span);
private:
SpanList _spanlist[NPAGES];
//std::map<PageID, Span*> _idspanmap;
std::unordered_map<PageID, Span*> _idspanmap;
std::mutex _mutex;
private:
PageCache(){}
PageCache(const PageCache&) = delete;
static PageCache _inst;
};
实现后补github地址==最近要开始复习巩固知识点了⛽