搜索历史

清空
搜索热词
      0
      • 聊天消息
      • 系统消息
      • 评论与回复
      查看更多
      查看更多
      查看更多
      登录后你可以
      • 下载海量资料
      • 学习在线课程
      • 观看技术视频
      • 写文章/发帖/加入社区
      创作中心
      发布
      创作活动

      完善资料让更多小伙伴认识你，还能领取20积分哦，立即完善>

      3天内不再提示

      内存池的使用场景

      科技绿洲 • 来源：Linux开发架构之路 • 作者：Linux开发架构之路 • 2023-11-10 17:19 • 次阅读

      为什么要用内存池

      为什么要用内存池？首先，在7 * 24h的服务器中如果不使用内存池，而使用malloc和free，那么就非常容易产生内存碎片，早晚都会申请内存失败；并且在比较复杂的代码或者继承的屎山中，非常容易出现内存泄漏导致mmo的问题。

      为了解决这两个问题，内存池就应运而生了。内存池预先分配一大块内存来做一个内存池，业务中的内存分配和释放都由这个内存池来管理，内存池内的内存不足时其内部会自己申请。所以内存碎片的问题就交由内存池的算法来优化，而内存泄漏的问题只需要遵守内存池提供的api，就非常容易避免内存泄漏了。

      即使出现了内存泄漏，排查的思路也很清晰。1.检查是不是内存池的问题；2.如果不是内存池的问题，就检查是不是第三方库的内存泄漏。

      内存池的使用场景

      1. 全局内存池
      2. 一个连接一个内存池(本文实现这个场景的内存池)

      设计一个内存池

      总体介绍

      由于本文是一个连接一个内存池，所以后续介绍和代码都是以4k为分界线，大于4k的我们认为是大块内存；小于4k的我们认为是小块内存。并且注意这里的4k，并不是严格遵照4096，而是在描述上，用4k比较好描述。

      在真正使用内存之前，内存池提前分配一定数量且大小相等的内存块以作备用，当真正被用户调用api分配内存的时候，直接从内存块中获取内存（指小块内存），当内存块不够用了，再有内存池取申请新的内存块。而如果是需要大块内存，则内存池直接申请大块内存再返回给用户。

      内存池：就是将这些提前申请的内存块组织管理起来的数据结构，内存池实现原理主要分为分配，回收，扩容三部分。

      内存池原理之小块内存：分配=> 内存池预申请一块4k的内存块，这里称为block，即block=4k内存块。当用户向内存池申请内存size小于4k时，内存池从block的空间中划分出去size空间，当再有新申请时，再划分出去。扩容=> 直到block中的剩余空间不足以分配size大小，那么此时内存池会再次申请一块block，再从新的block中划分size空间给用户。回收=> 每一次申请小内存，都会在对应的block中引用计数加1，每一次释放小内存时，都会在block中引用计数减1，只有当引用计数为零的时候，才会回收block使他重新成为空闲空间，以便重复利用空间。这样，内存池避免频繁向内核申请/释放内存，从而提高系统性能。

      内存池原理之大块内存：分配=> 因为大块内存是大于4k的，所以内存池不预先申请内存，也就是用户申请的时候，内存池再申请内存，然后返回给用户。扩容=> 大块内存不存在扩容。回收=> 对于大块内存来说，回收就直接free掉即可。

      上面理论讲完了，下面来介绍如何管理小块内存和大块内存。

      小块内存的分配与管理

      在创建内存池的时候，会预先申请一块4k的内存，并且在起始处将pool的结构体和node的结构体放进去，从last开始一直到end都是空闲内存，中间的区域就用来存储小块内存。每一次mp_malloc，就将last指针后移，直到 e n d − l a s t < s i z e end - last < size end−last

      初始状态

      图片

      分配内存

      图片

      扩容

      图片

      大块内存的分配与管理

      对于大块内存，前面已经说了，用户申请的时候，内存池才申请

      申请一块大内存

      图片

      再申请一块大内存

      图片

      内存池代码实现

      向外提供的api

      • mp_create_pool：创建一个线程池，其核心是创建struct mp_pool_s这个结构体，并申请4k内存，将各个指针指向上文初始状态的图一样。
      • mp_destroy_pool：销毁内存池，遍历小块结构体和大块结构体，进行free释放内存
      • mp_malloc：提供给用户申请内存的api
      • mp_calloc：通过mp_malloc申请内存后置零，相当于calloc
      • mp_free：释放由mp_malloc返回的内存
      • mp_reset_pool：将block的last置为初始状态，销毁所有大块内存
      • monitor_mp_poll：监控内存池状态
      struct mp_pool_s *mp_create_pool(size_t size);

void mp_destroy_pool(struct mp_pool_s *pool);

void *mp_malloc(struct mp_pool_s *pool, size_t size);

void *mp_calloc(struct mp_pool_s *pool, size_t size);

void mp_free(struct mp_pool_s *pool, void *p);

void mp_reset_pool(struct mp_pool_s *pool);

void monitor_mp_poll(struct mp_pool_s *pool, char *tk);

      相关结构体的定义

      mp_pool_s 就是整个内存池的管理结构，我们做的内存池是一个连接一个内存池，所以对于整个程序而言，内存池对象是有很多个的。

      可能读者会有疑问，有了head，为什么还有current，是因为如果一个block剩余空间小于size超过一定次数后，将current指向下一个block，这样就加快内存分配效率，减少遍历次数。

      //每4k一block结点
struct mp_node_s {
    unsigned char *end;//块的结尾
    unsigned char *last;//使用到哪了
    struct mp_node_s *next;//链表
    int quote;//引用计数
    int failed;//失效次数
};

struct mp_large_s {
    struct mp_large_s *next;//链表
    int size;//alloc的大小
    void *alloc;//大块内存的起始地址
};

struct mp_pool_s {
    struct mp_large_s *large;
    struct mp_node_s *head;
    struct mp_node_s *current;
};

      内存对齐

      访问速度是内存对齐的原因之一，另外一个原因是某些平台(arm)不支持未内存对齐的访问

      在4k里面划分内存，那么必然有很多地方是不对齐的，所以这里提供两个内存对齐的函数。那么为什么要内存对齐呢？其一：提高访问速度；其二：某些平台arm不支持未对其的内存访问，会出错。

      #define mp_align(n, alignment) (((n)+(alignment-1)) & ~(alignment-1))
#define mp_align_ptr(p, alignment) (void *)((((size_t)p)+(alignment-1)) & ~(alignment-1))

      创建与销毁内存池

      创建一个线程池，其核心是创建struct mp_pool_s这个结构体，并申请4k内存，将各个指针指向上文初始状态的图一样。
      销毁内存池，遍历小块结构体和大块结构体，进行free释放内存。

      //创建内存池
struct mp_pool_s *mp_create_pool(size_t size) {
    struct mp_pool_s *pool;
    if (size < PAGE_SIZE || size % PAGE_SIZE != 0) {
        size = PAGE_SIZE;
    }
    //分配4k以上不用malloc，用posix_memalign
    /*
        int posix_memalign (void **memptr, size_t alignment, size_t size);
     */

    int ret = posix_memalign((void **) &pool, MP_ALIGNMENT, size); //4K + mp_pool_s
    if (ret) {
        return NULL;
    }
    pool- >large = NULL;
    pool- >current = pool- >head = (unsigned char *) pool + sizeof(struct mp_pool_s);
    pool- >head- >last = (unsigned char *) pool + sizeof(struct mp_pool_s) + sizeof(struct mp_node_s);
    pool- >head- >end = (unsigned char *) pool + PAGE_SIZE;
    pool- >head- >failed = 0;

    return pool;
}

//销毁内存池
void mp_destroy_pool(struct mp_pool_s *pool) {
    struct mp_large_s *large;
    for (large = pool- >large; large; large = large- >next) {
        if (large- >alloc) {
            free(large- >alloc);
        }
    }

    struct mp_node_s *cur, *next;
    cur = pool- >head- >next;

    while (cur) {
        next = cur- >next;
        free(cur);
        cur = next;
    }
    free(pool);
}

      图片

      提供给用户的内存申请api

      申请的内存以size做区分，如果大于4k就分配大块内存，小于4k就去block里面划分。

      //分配内存
void *mp_malloc(struct mp_pool_s *pool, size_t size) {
    if (size <= 0) {
        return NULL;
    }
    if (size > PAGE_SIZE - sizeof(struct mp_node_s)) {
        //large
        return mp_malloc_large(pool, size);
    }
    else {
        //small
        unsigned char *mem_addr = NULL;
        struct mp_node_s *cur = NULL;
        cur = pool- >current;
        while (cur) {
            mem_addr = mp_align_ptr(cur- >last, MP_ALIGNMENT);
            if (cur- >end - mem_addr >= size) {
                cur- >quote++;//引用+1
                cur- >last = mem_addr + size;
                return mem_addr;
            }
            else {
                cur = cur- >next;
            }
        }
        return mp_malloc_block(pool, size);// open new space
    }
}
void *mp_calloc(struct mp_pool_s *pool, size_t size) {
    void *mem_addr = mp_malloc(pool, size);
    if (mem_addr) {
        memset(mem_addr, 0, size);
    }
    return mem_addr;
}

      小块内存block扩容

      所有的block都 e n d − l a s t < s i z e end - last < size end−last

      //new block 4k
void *mp_malloc_block(struct mp_pool_s *pool, size_t size) {
    unsigned char *block;
    int ret = posix_memalign((void **) &block, MP_ALIGNMENT, PAGE_SIZE); //4K
    if (ret) {
        return NULL;
    }
    struct mp_node_s *new_node = (struct mp_node_s *) block;
    new_node- >end = block + PAGE_SIZE;
    new_node- >next = NULL;

    unsigned char *ret_addr = mp_align_ptr(block + sizeof(struct mp_node_s), MP_ALIGNMENT);

    new_node- >last = ret_addr + size;
    new_node- >quote++;

    struct mp_node_s *current = pool- >current;
    struct mp_node_s *cur = NULL;

    for (cur = current; cur- >next; cur = cur- >next) {
        if (cur- >failed++ > 4) {
            current = cur- >next;
        }
    }
    //now cur = last node
    cur- >next = new_node;
    pool- >current = current;
    return ret_addr;
}

      分配大块内存

      //size >4k
void *mp_malloc_large(struct mp_pool_s *pool, size_t size) {
    unsigned char *big_addr;
    int ret = posix_memalign((void **) &big_addr, MP_ALIGNMENT, size); //size
    if (ret) {
        return NULL;
    }

    struct mp_large_s *large;
    //released struct large resume
    int n = 0;
    for (large = pool- >large; large; large = large- >next) {
        if (large- >alloc == NULL) {
            large- >size = size;
            large- >alloc = big_addr;
            return big_addr;
        }
        if (n++ > 3) {
            break;// 为了避免过多的遍历，限制次数
        }
    }
    large = mp_malloc(pool, sizeof(struct mp_large_s));
    if (large == NULL) {
        free(big_addr);
        return NULL;
    }
    large- >size = size;
    large- >alloc = big_addr;
    large- >next = pool- >large;
    pool- >large = large;
    return big_addr;
}

      释放内存

      如果是大块内存，找到之后直接释放；如果是小块内存，将引用计数减1，如果引用计数为0则重置last。

      //释放内存
void mp_free(struct mp_pool_s *pool, void *p) {
    struct mp_large_s *large;
    for (large = pool- >large; large; large = large- >next) {//大块
        if (p == large- >alloc) {
            free(large- >alloc);
            large- >size = 0;
            large- >alloc = NULL;
            return;
        }
    }
    //小块 引用-1
    struct mp_node_s *cur = NULL;
    for (cur = pool- >head; cur; cur = cur- >next) {
//        printf("cur:%p   p:%p   end:%pn", (unsigned char *) cur, (unsigned char *) p, (unsigned char *) cur- >end);
        if ((unsigned char *) cur <= (unsigned char *) p && (unsigned char *) p <= (unsigned char *) cur- >end) {
            cur- >quote--;
            if (cur- >quote == 0) {
                if (cur == pool- >head) {
                    pool- >head- >last = (unsigned char *) pool + sizeof(struct mp_pool_s) + sizeof(struct mp_node_s);
                }
                else {
                    cur- >last = (unsigned char *) cur + sizeof(struct mp_node_s);
                }
                cur- >failed = 0;
                pool- >current = pool- >head;
            }
            return;
        }
    }
}

      内存池测试

      //
// Created by 68725 on 2022/7/26.
//
#include < stdlib.h >
#include < stdio.h >
#include < string.h >

#define PAGE_SIZE 4096
#define MP_ALIGNMENT 16
#define mp_align(n, alignment) (((n)+(alignment-1)) & ~(alignment-1))
#define mp_align_ptr(p, alignment) (void *)((((size_t)p)+(alignment-1)) & ~(alignment-1))

//每4k一block结点
struct mp_node_s {
    unsigned char *end;//块的结尾
    unsigned char *last;//使用到哪了
    struct mp_node_s *next;//链表
    int quote;//引用计数
    int failed;//失效次数
};

struct mp_large_s {
    struct mp_large_s *next;//链表
    int size;//alloc的大小
    void *alloc;//大块内存的起始地址
};

struct mp_pool_s {
    struct mp_large_s *large;
    struct mp_node_s *head;
    struct mp_node_s *current;
};

struct mp_pool_s *mp_create_pool(size_t size);

void mp_destroy_pool(struct mp_pool_s *pool);

void *mp_malloc(struct mp_pool_s *pool, size_t size);

void *mp_calloc(struct mp_pool_s *pool, size_t size);

void mp_free(struct mp_pool_s *pool, void *p);

void mp_reset_pool(struct mp_pool_s *pool);

void monitor_mp_poll(struct mp_pool_s *pool, char *tk);


void mp_reset_pool(struct mp_pool_s *pool) {
    struct mp_node_s *cur;
    struct mp_large_s *large;

    for (large = pool- >large; large; large = large- >next) {
        if (large- >alloc) {
            free(large- >alloc);
        }
    }

    pool- >large = NULL;
    pool- >current = pool- >head;
    for (cur = pool- >head; cur; cur = cur- >next) {
        cur- >last = (unsigned char *) cur + sizeof(struct mp_node_s);
        cur- >failed = 0;
        cur- >quote = 0;
    }
}

//创建内存池
struct mp_pool_s *mp_create_pool(size_t size) {
    struct mp_pool_s *pool;
    if (size < PAGE_SIZE || size % PAGE_SIZE != 0) {
        size = PAGE_SIZE;
    }
    //分配4k以上不用malloc，用posix_memalign
    /*
        int posix_memalign (void **memptr, size_t alignment, size_t size);
     */

    int ret = posix_memalign((void **) &pool, MP_ALIGNMENT, size); //4K + mp_pool_s
    if (ret) {
        return NULL;
    }
    pool- >large = NULL;
    pool- >current = pool- >head = (unsigned char *) pool + sizeof(struct mp_pool_s);
    pool- >head- >last = (unsigned char *) pool + sizeof(struct mp_pool_s) + sizeof(struct mp_node_s);
    pool- >head- >end = (unsigned char *) pool + PAGE_SIZE;
    pool- >head- >failed = 0;

    return pool;
}

//销毁内存池
void mp_destroy_pool(struct mp_pool_s *pool) {
    struct mp_large_s *large;
    for (large = pool- >large; large; large = large- >next) {
        if (large- >alloc) {
            free(large- >alloc);
        }
    }

    struct mp_node_s *cur, *next;
    cur = pool- >head- >next;

    while (cur) {
        next = cur- >next;
        free(cur);
        cur = next;
    }
    free(pool);
}

//size >4k
void *mp_malloc_large(struct mp_pool_s *pool, size_t size) {
    unsigned char *big_addr;
    int ret = posix_memalign((void **) &big_addr, MP_ALIGNMENT, size); //size
    if (ret) {
        return NULL;
    }

    struct mp_large_s *large;
    //released struct large resume
    int n = 0;
    for (large = pool- >large; large; large = large- >next) {
        if (large- >alloc == NULL) {
            large- >size = size;
            large- >alloc = big_addr;
            return big_addr;
        }
        if (n++ > 3) {
            break;// 为了避免过多的遍历，限制次数
        }
    }
    large = mp_malloc(pool, sizeof(struct mp_large_s));
    if (large == NULL) {
        free(big_addr);
        return NULL;
    }
    large- >size = size;
    large- >alloc = big_addr;
    large- >next = pool- >large;
    pool- >large = large;
    return big_addr;
}

//new block 4k
void *mp_malloc_block(struct mp_pool_s *pool, size_t size) {
    unsigned char *block;
    int ret = posix_memalign((void **) &block, MP_ALIGNMENT, PAGE_SIZE); //4K
    if (ret) {
        return NULL;
    }
    struct mp_node_s *new_node = (struct mp_node_s *) block;
    new_node- >end = block + PAGE_SIZE;
    new_node- >next = NULL;

    unsigned char *ret_addr = mp_align_ptr(block + sizeof(struct mp_node_s), MP_ALIGNMENT);

    new_node- >last = ret_addr + size;
    new_node- >quote++;

    struct mp_node_s *current = pool- >current;
    struct mp_node_s *cur = NULL;

    for (cur = current; cur- >next; cur = cur- >next) {
        if (cur- >failed++ > 4) {
            current = cur- >next;
        }
    }
    //now cur = last node
    cur- >next = new_node;
    pool- >current = current;
    return ret_addr;
}

//分配内存
void *mp_malloc(struct mp_pool_s *pool, size_t size) {
    if (size <= 0) {
        return NULL;
    }
    if (size > PAGE_SIZE - sizeof(struct mp_node_s)) {
        //large
        return mp_malloc_large(pool, size);
    }
    else {
        //small
        unsigned char *mem_addr = NULL;
        struct mp_node_s *cur = NULL;
        cur = pool- >current;
        while (cur) {
            mem_addr = mp_align_ptr(cur- >last, MP_ALIGNMENT);
            if (cur- >end - mem_addr >= size) {
                cur- >quote++;//引用+1
                cur- >last = mem_addr + size;
                return mem_addr;
            }
            else {
                cur = cur- >next;
            }
        }
        return mp_malloc_block(pool, size);// open new space
    }
}

void *mp_calloc(struct mp_pool_s *pool, size_t size) {
    void *mem_addr = mp_malloc(pool, size);
    if (mem_addr) {
        memset(mem_addr, 0, size);
    }
    return mem_addr;
}

//释放内存
void mp_free(struct mp_pool_s *pool, void *p) {
    struct mp_large_s *large;
    for (large = pool- >large; large; large = large- >next) {//大块
        if (p == large- >alloc) {
            free(large- >alloc);
            large- >size = 0;
            large- >alloc = NULL;
            return;
        }
    }
    //小块 引用-1
    struct mp_node_s *cur = NULL;
    for (cur = pool- >head; cur; cur = cur- >next) {
//        printf("cur:%p   p:%p   end:%pn", (unsigned char *) cur, (unsigned char *) p, (unsigned char *) cur- >end);
        if ((unsigned char *) cur <= (unsigned char *) p && (unsigned char *) p <= (unsigned char *) cur- >end) {
            cur- >quote--;
            if (cur- >quote == 0) {
                if (cur == pool- >head) {
                    pool- >head- >last = (unsigned char *) pool + sizeof(struct mp_pool_s) + sizeof(struct mp_node_s);
                }
                else {
                    cur- >last = (unsigned char *) cur + sizeof(struct mp_node_s);
                }
                cur- >failed = 0;
                pool- >current = pool- >head;
            }
            return;
        }
    }
}

void monitor_mp_poll(struct mp_pool_s *pool, char *tk) {
    printf("rnrn------start monitor poll------%srnrn", tk);
    struct mp_node_s *head = NULL;
    int i = 0;
    for (head = pool- >head; head; head = head- >next) {
        i++;
        if (pool- >current == head) {
            printf("current== >第%d块n", i);
        }
        if (i == 1) {
            printf("第%02d块small block  已使用:%4ld  剩余空间:%4ld  引用:%4d  failed:%4dn", i,
                   (unsigned char *) head- >last - (unsigned char *) pool,
                   head- >end - head- >last, head- >quote, head- >failed);
        }
        else {
            printf("第%02d块small block  已使用:%4ld  剩余空间:%4ld  引用:%4d  failed:%4dn", i,
                   (unsigned char *) head- >last - (unsigned char *) head,
                   head- >end - head- >last, head- >quote, head- >failed);
        }
    }
    struct mp_large_s *large;
    i = 0;
    for (large = pool- >large; large; large = large- >next) {
        i++;
        if (large- >alloc != NULL) {
            printf("第%d块large block  size=%dn", i, large- >size);
        }
    }
    printf("rnrn------stop monitor poll------rnrn");
}



int main() {
    struct mp_pool_s *p = mp_create_pool(PAGE_SIZE);
    monitor_mp_poll(p, "create memory pool");
#if 0
    printf("mp_align(5, %d): %d, mp_align(17, %d): %dn", MP_ALIGNMENT, mp_align(5, MP_ALIGNMENT), MP_ALIGNMENT,
           mp_align(17, MP_ALIGNMENT));
    printf("mp_align_ptr(p- >current, %d): %p, p- >current: %pn", MP_ALIGNMENT, mp_align_ptr(p- >current, MP_ALIGNMENT),
           p- >current);
#endif
    void *mp[30];
    int i;
    for (i = 0; i < 30; i++) {
        mp[i] = mp_malloc(p, 512);
    }
    monitor_mp_poll(p, "申请512字节30个");

    for (i = 0; i < 30; i++) {
        mp_free(p, mp[i]);
    }
    monitor_mp_poll(p, "销毁512字节30个");

    int j;
    for (i = 0; i < 50; i++) {
        char *pp = mp_calloc(p, 32);
        for (j = 0; j < 32; j++) {
            if (pp[j]) {
                printf("calloc wrongn");
                exit(-1);
            }
        }
    }
    monitor_mp_poll(p, "申请32字节50个");

    for (i = 0; i < 50; i++) {
        char *pp = mp_malloc(p, 3);
    }
    monitor_mp_poll(p, "申请3字节50个");


    void *pp[10];
    for (i = 0; i < 10; i++) {
        pp[i] = mp_malloc(p, 5120);
    }
    monitor_mp_poll(p, "申请大内存5120字节10个");

    for (i = 0; i < 10; i++) {
        mp_free(p, pp[i]);
    }
    monitor_mp_poll(p, "销毁大内存5120字节10个");

    mp_reset_pool(p);
    monitor_mp_poll(p, "reset pool");

    for (i = 0; i < 100; i++) {
        void *s = mp_malloc(p, 256);
    }
    monitor_mp_poll(p, "申请256字节100个");

    mp_destroy_pool(p);
    return 0;
}

      图片

      nginx内存池对比分析

      相关结构体定义对比

      图片

      创建内存池对比

      图片

      内存申请对比

      图片

      声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容侵权或者其他违规问题，请联系本站处理。 举报投诉
      • 服务器
        服务器
        +关注

        关注

        12

        文章

        8125

        浏览量

        82543
      • 内存
        内存
        +关注

        关注

        8

        文章

        2767

        浏览量

        72779
      • API
        API
        +关注

        关注

        2

        文章

        1384

        浏览量

        60997
      • malloc
        malloc
        +关注

        关注

        0

        文章

        52

        浏览量

        38
      收藏 人收藏

        评论

        相关推荐

        MOS管的应用场景

        mos管的应用场景，你了解么？低压MOS管可称为金属氧化物半导体场效应管，因为低压MOS管具有良好的开关特性，广泛应用在电子开关的电路中。如开关电源，电动马达、照明调光等！下面银联宝科技就跟大家一起
        发表于 11-14 09:24

        this的使用场景及与C,Java中的this的区别

        【JS】this有哪些使用场景？跟C,Java中的this有什么区别？如何改变this的值？
        发表于 03-11 10:17

        Linux内存系统：内存使用场景

        out of memory 的时代过去了吗？no，内存再充足也不可任性使用。1、内存的使用场景· page 管理· slab（kmalloc、内存池
        发表于 08-25 07:42

        =>的使用场景有哪些

        使用场景
        发表于 10-27 13:25

        蓝牙低功耗常见的应用场景及架构

        浅谈蓝牙低功耗（BLE）的几种常见的应用场景及架构
        发表于 06-15 09:51

        FPGA的应用场景

        目录文章目录目录FPGAFPGA 的应用场景FPGA 的技术难点FPGA 的工作原理FPGA 的体系结构FPGA 的开发FPGA 的使用FPGA 的优缺点参考文档FPGAFPGA（Field
        发表于 07-28 08:43

        ARM的技术特征是什么？应用场景有哪些？

        ARM的技术特征是什么？应用场景有哪些？
        发表于 11-05 07:32

        内存池可以调节内存的大小吗

        嵌入式–内存池直接上代码，自己体会。嵌入式设备，一般keil提供的堆很小，一般都不使用。使用内存池，自己可以调节内存大小。头文件 mallo
        发表于 12-17 07:00

        内存池的概念和实现原理概述

        { //一：内存池的概念和实现原理概述//malloc：内存浪费，频繁分配小块内存，则浪费更加显得明显//“内存
        发表于 12-17 06:44

        MS9331的应用场景是什么？

        MS9331的应用场景是什么？
        发表于 02-11 06:41

        关于RT-Thread内存管理的内存池简析

        这篇文章继续介绍 RT-Thread 内存管理剩下的部分——内存池。为何引入内存池？内存堆虽然方
        发表于 04-06 17:02

        RT-Thread内存管理之内存池实现分析

        适合它们的高效率的内存分配算法，就将变得复杂化。RT-Thread 操作系统在内存管理上，根据上层应用及系统资源的不同，有针对性地提供了不同的内存分配管理算法。总体上可分为两类：内存堆
        发表于 10-17 15:06

        labview 和 wincc 的区别 使用场景

        labview 和 wincc 的区别 使用场景 都是上位机软件，都可以做监控软件 wincc的名气也比较大 对比的资料较少 写这些文章的人，从自己的从事的行业出发，带有自己的思维 使用的场景 肯定
        发表于 10-27 18:01

        如何实现一个高性能内存池

        写在前面 本文的内存池代码是改编自Nginx的内存池源码，思路几乎一样。由于Nginx源码的变量命名我不喜欢，又没有注释，看得我很难受。想自己写一版容易理解的代码。 应用场景 写内存池
        的头像 发表于 11-10 11:11 •252次阅读
        如何实现一个高性能<b class='flag-5'>内存</b>池

        英伟达H200和A100的区别

        英伟达H200和A100两款芯片在性能、架构、内存以及应用场景等多个方面存在显著的区别。
        的头像 发表于 03-07 16:23 •803次阅读
        华秋（原“华强聚丰”）：
        电子发烧友
        华秋开发
        华秋电路(原"华强PCB")
        华秋商城(原"华强芯城")
        华秋智造
        My ElecFans
        APP
        网站地图
        设计技术
        可编程逻辑
        电源/新能源
        MEMS/传感技术
        测量仪表
        嵌入式技术
        制造/封装
        模拟技术
        RF/无线
        接口/总线/驱动
        处理器/DSP
        EDA/IC设计
        存储技术
        光电显示
        EMC/EMI设计
        连接器
        行业应用
        LEDs
        汽车电子
        音视频及家电
        通信网络
        医疗电子
        人工智能
        虚拟现实
        可穿戴设备
        机器人
        安全设备/系统
        军用/航空电子
        移动通信
        工业控制
        便携设备
        触控感测
        物联网
        智能电网
        区块链
        新科技
        特色内容
        专栏推荐
        学院
        设计资源
        设计技术
        电子百科
        电子视频
        元器件知识
        工具箱
        VIP会员
        最新技术文章
        社区
        小组
        论坛
        问答
        评测试用
        企业服务
        产品
        资料
        文章
        方案
        企业
        供应链服务
        硬件开发
        华秋电路
        华秋商城
        华秋智造
        nextPCB
        BOM配单
        媒体服务
        网站广告
        在线研讨会
        活动策划
        新闻发布
        新品发布
        小测验
        设计大赛
        华秋
        关于我们
        投资关系
        新闻动态
        加入我们
        联系我们
        举报投诉
        社交网络
        微博
        移动端
        发烧友APP
        硬声APP
        WAP
        联系我们
        广告合作
        王婉珠：wangwanzhu@elecfans.com
        内容合作
        黄晶晶：huangjingjing@elecfans.com
        内容合作（海外）
        张迎辉：mikezhang@elecfans.com
        供应链服务 PCB/IC/PCBA
        江良华：lanhu@huaqiu.com
        投资合作
        曾海银：zenghaiyin@huaqiu.com
        社区合作
        刘勇：liuyong@huaqiu.com

        • 关注我们的微信

          关注我们的微信

        • 下载发烧友APP

          下载发烧友APP

        • 电子发烧友观察

          电子发烧友观察
        华秋发烧友
        电子工程师社区
        华秋电路
        1-32层PCB打样·中小批量
        华秋商城
        元器件现货·全球代购·SmartBOM
        华秋智造
        SMT贴片·PCBA加工
        NextPCB
        PCB Manufacturer

        版权所有 © 湖南华秋数字科技有限公司

        电子发烧友 （电路图） 湘公网安备43011202000918 电信与信息服务业务经营许可证：合字B2-20210191 工商网监认证工商网监 湘ICP备 2023018690 号