CPP_STL——内存池（附源代码）

最新推荐文章于 2024-07-29 17:54:58 发布
最新推荐文章于 2024-07-29 17:54:58 发布
阅读量838 收藏 1
点赞数 2
分类专栏： C++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cute_shuai/article/details/81253832
版权

内存碎片
讲述内存池之前，先来说一下内存碎片的概念。物理内存实际的存储空间是连续的，内存没有被使用之前，进程刚跑起来的时候确实是顺序使用的，但是在系统中不断有进程提起，退出。这样内存在不停的被申请和释放，可用的物理内存空间不再连续，会产生很多的碎片，这就是内存碎片。
内存碎片过多，将造成内存的可用性降低，实际能用的内存没有剩余那么多，好比把一个亿分别存到一亿张银行卡一样，刷卡的时候每次只能刷一块钱的商品，有买汽车的能力却买不了，因为没有集中起来。
001
内存池
内存池其实就是进程先向系统申请一大块内存，然后该进程把这块内存管理起来，用的时候直接从这大块内存取，不再向系统索取，直到这大块用完才和系统申请，这样能减少操作系统的负担，提高效率。
并且，对这大块内存进行有效的管理，进程需要使用小内存时，就分配小内存块，需要连续的大内存才分配大内存块。这样有效的减少的内存碎片的产生。

一级空间配置器
其实这个很简单，就是申请的时候还是用malloc跟系统申请内存，释放的时候就释放，只不过，如果申请失败会调用一个能释放内存成功的函数，再申请内存。这个函数在一级空间配置器里用函数指针保存，通常这个指针都是为0，需要自己定义，没有定义又申请内存失败就会抛异常。

二级空间配置器
可以使用空间配置器，对内存池进行有效的管理。每次通过空间配置器向操作系统申请和释放内存，但是实际什么时候申请和释放由配置器决定，图解如下：
002

但是这样还无法解决内存碎片的问题，那么STL里面的空间配置器是如何解决的呢？
1.还是需要使用内存池
2.使用哈希桶，以8字节大小为小内存块，128字节为大内存块，哈希表的长度就是128/8 = 16，每个元素挂着对应内存块的大小为（下标+1）*8
3.进程申请内存，向上取8的整数倍，就直接从哈系表下面取相应大小的内存块，申请大内存用大内存块，申请小内存用小内存块，有效解决内存碎片问题。
4.假如申请15字节内存，去哈希表下标为1的元素下边拿内存块，如果已经拿完了，就去内存池取，每次去内存池取的时候都取20块16字节内存，然后挂19块，返回1块给进程。不足20块，就有多少块拿多少块。
5.如果申请的内存大于最大内存块，那就和一级空间配置器申请吧
6.如果内存池的内存也用完啦咋办呢？那就只能向操作系统再要一大块内存给内存池补点货了。但是也是存在申请失败的情况，失败了在哈希表里一直往右搜索比申请的内存更大的内存块，找到了就给了，找到最后还是没有，就去和一级空间配置器商量一下要点内存吧。
7.释放内存，其实只是把释放的内存块挂在了哈希表下面，只有超过了最大内存块的内存才会调用一级空间配置器释放。
003

代码

#pragma once

#include "TraceLog.h"

typedef void(*HANDLE_FUNC)();

//一级空间配置器
template <int inst>
class __MallocAllocTemplate {

private:
    static void* OOM_Malloc(size_t n)   //释放空间再申请空间
    {
        while (1)
        {
            if (__malloc_alloc_oom_handler == 0)
            {
                throw bad_alloc();
            }
            __malloc_alloc_oom_handler();

            void *p = malloc(n);
            if (p)
                return p;
        }
    }


    static HANDLE_FUNC __malloc_alloc_oom_handler;
public:
    static void* Allocate(size_t n)
    {
        void *p = malloc(n);
        if (p == NULL)
            p = OOM_Malloc(n);

        return p;
    }

    static void Deallocate(void *p, size_t /* n */)
    {
        free(p);
    }

    static HANDLE_FUNC SetMallocHandler(HANDLE_FUNC f)  //给释放内存函数指针赋值
    {
        HANDLE_FUNC old = __malloc_alloc_oom_handler;
        __malloc_alloc_oom_handler = f;
        return old;
    }
};

template<int inst>
HANDLE_FUNC __MallocAllocTemplate<inst>::__malloc_alloc_oom_handler = 0;        //类外初始化

#include <windows.h>

void FreeHandle()
{
    cout<<"释放内存"<<endl;
    Sleep(1000);
}

void TestMallocAlloc()
{
    __MallocAllocTemplate<0>::SetMallocHandler(FreeHandle);
    void* p1 = __MallocAllocTemplate<0>::Allocate(10);
    void* p2 = __MallocAllocTemplate<0>::Allocate(0x7fffffff);
}


/////////////////////////////////////////////////////////
//

//二级空间配置器（内存池）
template <bool threads, int inst>
class __DefaultAllocTemplate
{
public:
    static  size_t FREELIST_INDEX(size_t bytes)      //查找索引
    {           
        return (((bytes) + __ALIGN-1)/__ALIGN - 1);
    }

    static size_t ROUND_UP(size_t bytes) {                  //向上取8的倍数
        return (((bytes) + __ALIGN-1) & ~(__ALIGN - 1));
    }

    static char* ChunkAlloc(size_t size, size_t& nobjs)         //大块申请
    {
        size_t totalSize = size * nobjs;
        size_t realSize = _endfree - _startfree;
        if (realSize >= totalSize)
        {
//          __TRACE_DEBUG("内存池中有足够20个对象大块内存\n");
            char* chunk = _startfree;
            _startfree += totalSize;
            return chunk;
        }
        else if (realSize >= size)
        {
//          __TRACE_DEBUG("内存池中只有%u个对象大块内存\n", nobjs);
            nobjs = realSize / size;
            char* chunk = _startfree;
            _startfree += size*nobjs;
            return chunk;
        }
        else
        {
//          __TRACE_DEBUG("内存池中一个对象都不够\n");
            if (realSize > 0)
            {
                size_t index = FREELIST_INDEX(realSize);
                ((Obj*)_startfree)->_freelistlink = _freelist[index];
                _freelist[index] = (Obj*)_startfree;
            }

//          __TRACE_DEBUG("向系统申请%ubytes字节\n", byetstoget);
            //内存池没空间了，和系统申请
            realSize = totalSize * 2 + ROUND_UP(_heapsize >> 4);
            _startfree = (char*)malloc(realSize);
            if (_startfree == NULL)     //申请失败
            {
                //取出大于size的链表下的内存块使用
                size_t index = FREELIST_INDEX(totalSize);
                while (index < __NFREELISTS)  //小于哈希表的长度
                {
                    if (_freelist[index] != NULL)       //找到不为空的结点下标
                    {
                        _startfree = (char*)_freelist[index];           //取出来
                        _freelist[index] = _freelist[index]->_freelistlink;  

                        _endfree = _startfree + (index + 1)*__ALIGN;
                        return ChunkAlloc(size, nobjs);
                    }
                    index++;
                }

                //走到这里说明，哈希表index+后面也没有挂多余的内存了
                //和系统又申请失败， 则用一级空间配置器申请
                _startfree = (char*)__MallocAllocTemplate<0>::Allocate(realSize);
            }

            _endfree = _startfree + realSize;
            _heapsize += realSize;
            return ChunkAlloc(size, nobjs);
        }
    }

    static void* Refill(size_t size)        //填充
    {
        size_t nobjs = 20;

        char* p = ChunkAlloc(size, nobjs);
        if (nobjs == 1)
            return p;
        size_t index = FREELIST_INDEX(size);
        char* cur = p;
        p += size;
        _freelist[index] = (Obj*)p;
        for (size_t i = 0; i < nobjs-2; i++)
        {
            Obj* next = (Obj*)(p+size);
            ((Obj*)p)->_freelistlink = next;
            p = (char*)next;
        }
        ((Obj*)p)->_freelistlink = NULL;
        return cur;
    }

    static void* Allocate(size_t n)         //申请内存
    {
        if (n > __MAX_BYTES)        //申请大小超过最大内存大小，就用一级空间配置器申请空间返回
        {
            return __MallocAllocTemplate<0>::Allocate(n);
        }
        else                      //申请大小小于最大内存块
        {
            size_t index = FREELIST_INDEX(n);
            if (_freelist[index] == NULL)
            {
                return Refill(ROUND_UP(n));     //没有挂空间就去申请挂一些
            }
            else
            {
                Obj* cur = _freelist[index];
                _freelist[index] = _freelist[index]->_freelistlink;
                return cur;
            }
        }

    }

    static void Deallocate(void* p, size_t n)
    {
        //判断n是否大于最大内存块
        if (n > __MAX_BYTES)
        {
            __MallocAllocTemplate<0>::Deallocate(p, n);
        }
        else   //把释放的空间挂回哈希表，不直接还给系统
        {
            size_t index = FREELIST_INDEX(n);
            ((Obj*)p)->_freelistlink = _freelist[index];
            _freelist[index] = (Obj*)p;
        }
    }


protected:
    enum {__ALIGN = 8};         //小块内存
    enum {__MAX_BYTES = 128};   //大块内存
    enum {__NFREELISTS = __MAX_BYTES/__ALIGN};      //哈希表长度 128/8=16

    union Obj
    {
        union Obj* _freelistlink;   //char** 二级指针
        char _client[1];
    };

    // 自由链表配合管理
    static Obj* _freelist[__NFREELISTS];

    // 内存池
    static char* _startfree;        //开始
    static char* _endfree;          //结束
    static size_t _heapsize;        //内存池大小
}; 

template <bool threads, int inst>
typename __DefaultAllocTemplate<threads, inst>::Obj*
__DefaultAllocTemplate<threads, inst>::_freelist[__NFREELISTS] = {0};

// 内存池
template <bool threads, int inst>
char* __DefaultAllocTemplate<threads, inst>::_startfree = NULL;

template <bool threads, int inst>
char* __DefaultAllocTemplate<threads, inst>::_endfree = NULL;

template <bool threads, int inst>
size_t __DefaultAllocTemplate<threads, inst>::_heapsize = 0;

#ifdef __USE_MALLOC
typedef __MallocAllocTemplate<0> alloc;
#else
typedef __DefaultAllocTemplate<false, 0> alloc;
#endif // __USE_MALLOC


void TestDefaultAlloc()
{
    for(size_t i = 0; i < 21; ++i)
    {
        __TRACE_DEBUG("申请第%u个对象\n", i);
        __DefaultAllocTemplate<false, 0>::Allocate(7);
    }
}

template<class T, class Alloc>
class SimpleAlloc {

public:
    static T* Allocate(size_t n)
    { return 0 == n? 0 : (T*) Alloc::Allocate(n * sizeof (T)); }

    static T* Allocate(void)
    { return (T*) Alloc::Allocate(sizeof (T)); }

    static void Deallocate(T *p, size_t n)
    { if (0 != n) Alloc::Deallocate(p, n * sizeof (T)); }

    static void Deallocate(T *p)
    { Alloc::Deallocate(p, sizeof (T)); }
};
cute_shuai
关注
专栏目录
STL源码分析之内存池
啦啦啦
11-29 957
前言 上一节只分析了第二级配置器是由多个链表来存放相同内存大小, 当没有空间的时候就向内存池索取就行了, 却没有具体分析内存池是怎么保存空间的, 是不是内存池真的有用不完的内存, 本节我们就具体来分析一下 内存池 static data template的初始化 template &amp;amp;lt;bool threads, int inst&amp;amp;gt; char *__default_alloc_templa...
stl内存池学习（一）——内存池初认识
houapple的记忆屋
04-13 7669
C++ 内存池（翻译）
10-05 169
原帖与示例代码地址：http://www.codeproject.com/KB/cpp/MemoryPool.aspx 译者点评：一个简单的内存池实现，附有源码，简单易懂，适合入门。 概述 在c/c++中，内存分配（如malloc或new）会使用很多时间。 一个程序会随着长时间的运行和内存的申请释放而变得越来越慢，内存也会随着时间逐渐碎片化。特别是高频率的进行小内存申...
boost库 内存池
最新发布
weixin_50873490的博客
07-29 1040
简单轻量:它是一个基础的内存管理工具,实现简单,开销较小。高效:通过维护内存块列表,可以快速分配和回收内存。可定制:提供了许多可配置的选项,如内存块大小、对齐方式等。可重用:可以被上层的内存池实现 (如) 重复利用。内存池管理Boost.Pool 提供了两种主要的内存池实现:和。它们都利用来管理内存块,提高内存利用率和缓存命中率。固定大小对象管理Boost.Pool 专注于管理固定大小的对象,这种设计能够提高内存管理的效率。它使用连续的内存块来存储这些对象,避免了频繁的new和。
C++内存池
sinat_31608641的博客
12-14 2797
内存池
27 CPP内存池
wade1010的专栏
12-18 117
组织数据的方法是，两个标志位，1个字节。之前用new和delete模拟了C++编译器分配内存和释放内存的方法，功能和效果与编译器默认提供的函数没什么区别，意义不大。当需要为超女分配内存的时候，先判断标志位是否被占用，如果没有被占用，就把标志位后面这个内存的地址返回。1 是提升分配和归还的效率，对高性能的服务程序来说，频繁的new和delete也算是浪费时间，2 减少内存碎片，碎片多了系统管理内存的效率就会下降，系统的性能也会下降。打算申请连续的18字节的内存空间，也就是说内存池的大小是18字节。
STL 入门学习 实例 源代码
10-11
STL（Standard ...在学习过程中，不要忘记结合源代码进行实践，因为理论与实际操作相结合是学习编程的最佳方式。这个“practstl”文件可能包含了更多类似的实例，继续探索和实验，将有助于巩固和深化STL的理解。
STL源码阅读小记(二)——Vector
ninesnow_c的博客
12-15 862
前言 最近事情都完成差不多了，看看vecotr实现吧。vector算是stl中很常见的容器了，可能很多人学完c++语法，接触stl就是从vector开始的。vector的数据结构就不细细说明了，相信大家对数组这数据结构绝对都懂。 另外看了标准库才明白要达到Standard Template实际上是很复杂的一件事。一些非常见的函数就只看看声明吧，以及一些类型萃取就不展示了，要完整的展示出来实在太太长了。一份vector<T>加上vector<bool>的源码大概在4000行左右。 博客
C++课程设计——通讯簿源代码
01-13
【C++课程设计——通讯簿源代码】 C++课程设计是一项常见的编程实践任务，旨在让学生深入理解面向对象编程（OOP）的概念，并将其应用于实际项目中。在这个项目中，我们关注的是一个通讯簿应用程序的开发，它允许...
《写给大家看的C++书》——源代码
05-29
在C++中，源代码通常以.cpp或.c为扩展名。书中提供的源代码可以帮助读者理解C++语法、数据类型、控制结构（如if语句、循环）、函数、类和对象等核心概念。通过查看并运行这些源代码，读者可以直观地看到理论知识如何...
c++STL学习——排序算法技术总结和用法代码实例(二)
10-21
接下来，让我们看看源代码实例。在文件“排序算法二”中，可能会包含这些排序算法的实际实现，以及如何在不同场景下使用它们。例如，可能会有一个例子展示如何自定义比较函数来对自定义类型的对象进行排序： ```cpp...
基于STL的内存池类
10-10
基于STL的内存池类 和 测试程序 在linux下已做过稳定性测试
几种内存池的实现(c/c++ 源码)
07-25
几种 内存池 的实现 (c/c++ 源码)
SGI STL中内存池的实现
weixin_30595035的博客
08-09 157
最近这两天研究了一下SGI STL中的内存池, 网上对于这一块的讲解很多, 但是要么讲的不完整, 要么讲的不够简单(至少对于我这样的初学者来讲是这样的...), 所以接下来我将把我对于对于SGI STL的理解写下来, 方便以后查阅同时也希望能够对像我一样刚刚接触C++的初学者提供一些帮助吧. 首先我们需要明确, 内存池的目的到底是什么? 首先你要知道的是, 我们每次使用new T来初始化...
C/C++ 内存管理（malloc/calloc/realloc、free 和 new 、 delete区别；内存泄漏）
qq_42433334的博客
05-27 458
C/C++内存分布 int globalVar = 1; static int staticGlobalVar = 1; //globalVar和staticGlobalVar是在main函数之前初始化，在哪都能用，作用域是全局的 /*区别：它俩的链接属性不一样，globalVar是所有文件可见，staticGlobalVar只在当前文件可见*/ void Test() { static int staticVar = 1; //运行到这里才初始化，它的作用域在Test函数中，只能在Test函数中使用
STL-内存池
qq_55439426的博客
10-17 1441
无
【c++】-STL内存池
weixin_42176221的博客
04-02 193
C++STL内存池 内存池的思路其实是这样的: 使用allocate向内存池请求size大小的内存空间, 如果需要请求的内存大小大于128bytes, 直接使用malloc. 如果需要的内存大小小于128bytes, allocate根据size找到最适合的自由链表. a. 如果链表不为空, 返回第一个node, 链表头改为第二个node. b. 如果链表为空, 使用blockA...
【STL】空间配置器剖析（三）--内存池
Always__的代码世界
04-28 1594
内存池 上篇文章的阅读量目前为止竟然高达4000+，让作者真是受宠若惊啊（呃呃呃。毕竟是一只菜鸟啊！）。 正文开始咯： 内存池 上篇文章我们对于对对象构造前的内存配置和对象析构后的空间释放进行深入探索。详细介绍了空间配置器的，第一级空间配置器（malloc_alloc_template）,第二级空间配置器（defalult_alloc_template）.这篇文章将针对free
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值