内存池简单案例

已于 2022-11-30 11:01:02 修改
阅读量748 收藏
点赞数
分类专栏： Nginx 文章标签： nginx 内存池
于 2022-11-30 10:59:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ddazz0621/article/details/128110875
版权

        本章借助nginx源码中实现的内存池模块，将其抽离出来并实现一个简单的demo用于比较说明内存池的优点。内存池结构详细说明请见另一篇博文Nginx学习之内存管理。

        首先，将nginx源码中ngx_palloc.h、ngx_palloc.c、ngx_alloc.h、ngx_alloc.c四个文件拷贝出来，对其做一下简单修改，使其不再依赖nginx项目源码。

        ngx_alloc.h具体代码如下：

/*
 * Copyright (C) Igor Sysoev
 * Copyright (C) Nginx, Inc.
 */

#ifndef _NGX_ALLOC_H_INCLUDED_
#define _NGX_ALLOC_H_INCLUDED_

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <inttypes.h>

#ifndef u_char
#define u_char	unsigned char
#endif

#ifndef ngx_uint_t
#define	ngx_uint_t	 unsigned int
#endif

#ifndef ngx_int_t
#define ngx_int_t	int
#endif

#ifndef ngx_inline
#define ngx_inline      inline
#endif

void *ngx_alloc(size_t size, void *log);
void *ngx_calloc(size_t size, void *log);

#define ngx_free          free

#define ngx_memzero(buf, n)       (void) memset(buf, 0, n)
#define ngx_memset(buf, c, n)     (void) memset(buf, c, n)


/*
 * Linux has memalign() or posix_memalign()
 * Solaris has memalign()
 * FreeBSD 7.0 has posix_memalign(), besides, early version's malloc()
 * aligns allocations bigger than page size at the page boundary
 */

#if (NGX_HAVE_POSIX_MEMALIGN || NGX_HAVE_MEMALIGN)

void *ngx_memalign(size_t alignment, size_t size, void *log);

#else

#define ngx_memalign(alignment, size, log)  ngx_alloc(size, log)

#endif


extern ngx_uint_t  ngx_pagesize;
extern ngx_uint_t  ngx_pagesize_shift;
extern ngx_uint_t  ngx_cacheline_size;


#endif /* _NGX_ALLOC_H_INCLUDED_ */

        ngx_alloc.c具体代码如下：

/*
 * Copyright (C) Igor Sysoev
 * Copyright (C) Nginx, Inc.
 */

#include "ngx_alloc.h"

ngx_uint_t  ngx_pagesize;
ngx_uint_t  ngx_pagesize_shift;
ngx_uint_t  ngx_cacheline_size;

void *
ngx_alloc(size_t size, void *log)
{
    void  *p;

    p = malloc(size);
    if (p == NULL) {
		printf("----------malloc(%u) failed---------\n", size);
    }

	// printf("----------malloc: %p:%u---------\n", p, size);
    return p;
}


void *
ngx_calloc(size_t size, void *log)
{
    void  *p;

    p = ngx_alloc(size, log);

    if (p) {
        ngx_memzero(p, size);
    }

    return p;
}


#if (NGX_HAVE_POSIX_MEMALIGN)

void *
ngx_memalign(size_t alignment, size_t size, void *log)
{
    void  *p;
    int    err;

    err = posix_memalign(&p, alignment, size);

    if (err) {
		printf("----------posix_memalign(%u, %u) failed---------\n", alignment, size);
        p = NULL;
    }

	printf("----------posix_memalign: %p:%u @%u---------\n",  p, size, alignment);

    return p;
}

#elif (NGX_HAVE_MEMALIGN)

void *
ngx_memalign(size_t alignment, size_t size, void *log)
{
    void  *p;

    p = memalign(alignment, size);
    if (p == NULL) {
		printf("----------memalign(%u, %u) failed---------\n", alignment, size);
    }

	printf("----------memalign: %p:%u @%u---------\n",  p, size, alignment);

    return p;
}

#endif

        ngx_palloc.h具体代码如下：

/*
 * Copyright (C) Igor Sysoev
 * Copyright (C) Nginx, Inc.
 */

#ifndef _NGX_PALLOC_H_INCLUDED_
#define _NGX_PALLOC_H_INCLUDED_

#include <stdio.h>
#include <errno.h>
#include "ngx_alloc.h"

#define ngx_close_file           close
#define ngx_close_file_n         "close()"

#define ngx_delete_file(name)    unlink((const char *) name)
#define ngx_delete_file_n        "unlink()"

#define NGX_ENOENT        ENOENT
#define ngx_errno         errno

#define  NGX_OK          0
#define  NGX_ERROR      -1
#define  NGX_AGAIN      -2
#define  NGX_BUSY       -3
#define  NGX_DONE       -4
#define  NGX_DECLINED   -5
#define  NGX_ABORT      -6

#define NGX_INVALID_FILE         -1
#define NGX_FILE_ERROR           -1

typedef int               			ngx_err_t;
typedef int                      	ngx_fd_t;
typedef struct ngx_pool_s			ngx_pool_t;
typedef struct ngx_chain_s			ngx_chain_t;

/*
 * NGX_MAX_ALLOC_FROM_POOL should be (ngx_pagesize - 1), i.e. 4095 on x86.
 * On Windows NT it decreases a number of locked pages in a kernel.
 */
#define NGX_MAX_ALLOC_FROM_POOL  (ngx_pagesize - 1)

#define NGX_DEFAULT_POOL_SIZE    (16 * 1024)

#define NGX_POOL_ALIGNMENT       16
#define NGX_MIN_POOL_SIZE                                                     \
    ngx_align((sizeof(ngx_pool_t) + 2 * sizeof(ngx_pool_large_t)),            \
              NGX_POOL_ALIGNMENT)

#ifndef NGX_ALIGNMENT
#define NGX_ALIGNMENT   sizeof(unsigned long)    /* platform word */
#endif

#define ngx_align_ptr(p, a)                                                   \
    (u_char *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))
			  
typedef void (*ngx_pool_cleanup_pt)(void *data);

typedef struct ngx_pool_cleanup_s  ngx_pool_cleanup_t;

struct ngx_pool_cleanup_s {
    ngx_pool_cleanup_pt   handler;
    void                 *data;
    ngx_pool_cleanup_t   *next;
};

typedef struct ngx_pool_large_s  ngx_pool_large_t;

struct ngx_pool_large_s {
    ngx_pool_large_t     *next;
    void                 *alloc;
};

typedef struct {
    u_char               *last;
    u_char               *end;
    ngx_pool_t           *next;
    ngx_uint_t            failed;
} ngx_pool_data_t;

struct ngx_pool_s {
    ngx_pool_data_t       d;
    size_t                max;
    ngx_pool_t           *current;
    ngx_chain_t          *chain;
    ngx_pool_large_t     *large;
    ngx_pool_cleanup_t   *cleanup;
    void            *log;
};

typedef struct {
    ngx_fd_t              fd;
    u_char               *name;
    void            	 *log;
} ngx_pool_cleanup_file_t;

ngx_pool_t *ngx_create_pool(size_t size, void *log);
void ngx_destroy_pool(ngx_pool_t *pool);
void ngx_reset_pool(ngx_pool_t *pool);

void *ngx_palloc(ngx_pool_t *pool, size_t size);
void *ngx_pnalloc(ngx_pool_t *pool, size_t size);
void *ngx_pcalloc(ngx_pool_t *pool, size_t size);
void *ngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment);
ngx_int_t ngx_pfree(ngx_pool_t *pool, void *p);

ngx_pool_cleanup_t *ngx_pool_cleanup_add(ngx_pool_t *p, size_t size);
void ngx_pool_run_cleanup_file(ngx_pool_t *p, ngx_fd_t fd);
void ngx_pool_cleanup_file(void *data);
void ngx_pool_delete_file(void *data);

#endif /* _NGX_PALLOC_H_INCLUDED_ */

        ngx_palloc.c具体代码如下：

/*
 * Copyright (C) Igor Sysoev
 * Copyright (C) Nginx, Inc.
 */

#include "ngx_palloc.h"

static ngx_inline void *ngx_palloc_small(ngx_pool_t *pool, size_t size,
    ngx_uint_t align);
static void *ngx_palloc_block(ngx_pool_t *pool, size_t size);
static void *ngx_palloc_large(ngx_pool_t *pool, size_t size);

void ngx_pool_cleanup_file(void *data);

ngx_pool_t *
ngx_create_pool(size_t size, void *log)
{
    ngx_pool_t  *p;

    p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log);
    if (p == NULL) {
        return NULL;
    }

    p->d.last = (u_char *) p + sizeof(ngx_pool_t);
    p->d.end = (u_char *) p + size;
    p->d.next = NULL;
    p->d.failed = 0;

    size = size - sizeof(ngx_pool_t);

	// 最多分1页内存大小
    p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL;

    p->current = p;
    p->chain = NULL;
    p->large = NULL;
    p->cleanup = NULL;
    p->log = log;

    return p;
}

void
ngx_destroy_pool(ngx_pool_t *pool)
{
    ngx_pool_t          *p, *n;
    ngx_pool_large_t    *l;
    ngx_pool_cleanup_t  *c;

	// 清理资源一些必要操作
    for (c = pool->cleanup; c; c = c->next) {
        if (c->handler) {
            printf("---------------c->handler(c->data)-----------------\n");
            c->handler(c->data);
        }
    }

#if (NGX_DEBUG)

    /*
     * we could allocate the pool->log from this pool
     * so we cannot use this log while free()ing the pool
     */

    for (l = pool->large; l; l = l->next) {
		printf("---------------free: %p-----------------\n", l->alloc);
    }

    for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
		
		printf("---------------free: %p, unused: %u-----------------\n", p, p->d.end - p->d.last);
		
        if (n == NULL) {
            break;
        }
    }

#endif

	// 释放大块内存
    for (l = pool->large; l; l = l->next) {
        if (l->alloc) {
            ngx_free(l->alloc);
        }
    }

	// 释放 pool 内存
    for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
        ngx_free(p);

        if (n == NULL) {
            break;
        }
    }
}

void
ngx_reset_pool(ngx_pool_t *pool)
{
    ngx_pool_t        *p;
    ngx_pool_large_t  *l;

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

    for (p = pool; p; p = p->d.next) {
        p->d.last = (u_char *) p + sizeof(ngx_pool_t);
        p->d.failed = 0;
    }

    pool->current = pool;
    pool->chain = NULL;
    pool->large = NULL;
}

void *
ngx_palloc(ngx_pool_t *pool, size_t size)
{
#if !(NGX_DEBUG_PALLOC)
    if (size <= pool->max) {
        return ngx_palloc_small(pool, size, 1);
    }
#endif

    return ngx_palloc_large(pool, size);
}

void *
ngx_pnalloc(ngx_pool_t *pool, size_t size)
{
#if !(NGX_DEBUG_PALLOC)
    if (size <= pool->max) {
        return ngx_palloc_small(pool, size, 0);
    }
#endif

    return ngx_palloc_large(pool, size);
}

static ngx_inline void *
ngx_palloc_small(ngx_pool_t *pool, size_t size, ngx_uint_t align)
{
    u_char      *m;
    ngx_pool_t  *p;

    p = pool->current;

    do {
        m = p->d.last;

        if (align) {
            m = ngx_align_ptr(m, NGX_ALIGNMENT);
        }

		// 如果该 pool 结构中满足size大小的内存，则返回
        if ((size_t) (p->d.end - m) >= size) {
            p->d.last = m + size;

            return m;
        }

		// 指向pool链表的下一个pool结构
        p = p->d.next;

    } while (p);

	// 如果所有的pool链表中没有符合的内存块，则重新申请一个pool
    return ngx_palloc_block(pool, size);
}

static void *
ngx_palloc_block(ngx_pool_t *pool, size_t size)
{
    u_char      *m;
    size_t       psize;
    ngx_pool_t  *p, *new;

    psize = (size_t) (pool->d.end - (u_char *) pool);

    m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);
    if (m == NULL) {
        return NULL;
    }

    new = (ngx_pool_t *) m;

    new->d.end = m + psize;
    new->d.next = NULL;
    new->d.failed = 0;

    m += sizeof(ngx_pool_data_t);
    m = ngx_align_ptr(m, NGX_ALIGNMENT);
    new->d.last = m + size;

    for (p = pool->current; p->d.next; p = p->d.next) {
        if (p->d.failed++ > 4) {
            pool->current = p->d.next;
        }
    }

    p->d.next = new;

    return m;
}

static void *
ngx_palloc_large(ngx_pool_t *pool, size_t size)
{
    void              *p;
    ngx_uint_t         n;
    ngx_pool_large_t  *large;

    p = ngx_alloc(size, pool->log);
    if (p == NULL) {
        return NULL;
    }

    n = 0;

    for (large = pool->large; large; large = large->next) {
        if (large->alloc == NULL) {
            large->alloc = p;
            return p;
        }

        if (n++ > 3) {
            break;
        }
    }

    large = ngx_palloc_small(pool, sizeof(ngx_pool_large_t), 1);
    if (large == NULL) {
        ngx_free(p);
        return NULL;
    }

    large->alloc = p;
    large->next = pool->large;
    pool->large = large;

    return p;
}

void *
ngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment)
{
    void              *p;
    ngx_pool_large_t  *large;

    p = ngx_memalign(alignment, size, pool->log);
    if (p == NULL) {
        return NULL;
    }

    large = ngx_palloc_small(pool, sizeof(ngx_pool_large_t), 1);
    if (large == NULL) {
        ngx_free(p);
        return NULL;
    }

    large->alloc = p;
    large->next = pool->large;
    pool->large = large;

    return p;
}

ngx_int_t
ngx_pfree(ngx_pool_t *pool, void *p)
{
    ngx_pool_large_t  *l;

    for (l = pool->large; l; l = l->next) {
        if (p == l->alloc) {
			
			printf("---------------free: %p-----------------\n", l->alloc);
			
            ngx_free(l->alloc);
            l->alloc = NULL;

            return NGX_OK;
        }
    }

    return NGX_DECLINED;
}

void *
ngx_pcalloc(ngx_pool_t *pool, size_t size)
{
    void *p;

    p = ngx_palloc(pool, size);
    if (p) {
        ngx_memzero(p, size);
    }

    return p;
}

ngx_pool_cleanup_t *
ngx_pool_cleanup_add(ngx_pool_t *p, size_t size)
{
    ngx_pool_cleanup_t  *c;

    c = ngx_palloc(p, sizeof(ngx_pool_cleanup_t));
    if (c == NULL) {
        return NULL;
    }

    if (size) {
        c->data = ngx_palloc(p, size);
        if (c->data == NULL) {
            return NULL;
        }

    } else {
        c->data = NULL;
    }

    c->handler = NULL;
    c->next = p->cleanup;

    p->cleanup = c;

	printf("---------------add cleanup: %p-----------------\n", c);

    return c;
}

void
ngx_pool_run_cleanup_file(ngx_pool_t *p, ngx_fd_t fd)
{
    ngx_pool_cleanup_t       *c;
    ngx_pool_cleanup_file_t  *cf;

    for (c = p->cleanup; c; c = c->next) {
        if (c->handler == ngx_pool_cleanup_file) {

            cf = c->data;

            if (cf->fd == fd) {
                c->handler(cf);
                c->handler = NULL;
                return;
            }
        }
    }
}

void
ngx_pool_cleanup_file(void *data)
{
    ngx_pool_cleanup_file_t  *c = data;

	printf("----------file cleanup: fd:%d---------\n", c->fd);

    if (ngx_close_file(c->fd) == NGX_FILE_ERROR) {
		printf("----------\"%s\" failed---------\n", c->name);
    }
}

void
ngx_pool_delete_file(void *data)
{
    ngx_pool_cleanup_file_t  *c = data;

    ngx_err_t  err;

	printf("----------file cleanup: fd:%d %s---------\n", c->fd, c->name);

    if (ngx_delete_file(c->name) == NGX_FILE_ERROR) {
        err = ngx_errno;

        if (err != NGX_ENOENT) {
			printf("----------\"%s\" failed---------\n",  c->name);
        }
    }

    if (ngx_close_file(c->fd) == NGX_FILE_ERROR) {
		printf("----------\"%s\" failed---------\n",  c->name);
    }
}

        测试主函数主要比较malloc/free申请内存及内存池申请的效率，main.c具体代码如下:

/***********************************************
*    Author : lijd
*    Date   : 2022-11-30
*	 Func   : 测试内存池功能主函数
***********************************************/

#include <stdio.h>

#include "ngx_palloc.h"

#define LOOP_NUM_1	(1024 * 400)
#define LOOP_NUM_2	(1024)
#define MEM_SIZE	16

#define MEM_POOL_SIZE (1024 * 4)

int main(int argc, char *const *argv)
{
	int i, j;
	if(argc == 1)
	{
		printf("-----------------malloc/free---------------\n");
		
		for(i = 0; i < LOOP_NUM_1; i++)
		{
			for(j = 0; j < LOOP_NUM_2; j++)
			{
				void *p = malloc(MEM_SIZE);
			
				if(p == NULL)
				{
					printf("malloc error !\n");
					return -1;
				}
				memset(p, 0, MEM_SIZE);
				free(p);
			}
		}
	}
	else
	{
		printf("-----------------mem pool---------------\n");
		
		for(i = 0; i < LOOP_NUM_1; i++)
		{
			ngx_pool_t *pool = ngx_create_pool(MEM_POOL_SIZE, NULL);
			
			for(j = 0; j < LOOP_NUM_2; j++)
			{
				void *p = ngx_palloc(pool, MEM_SIZE);
				
				if(p == NULL)
				{
					printf("ngx_palloc error !\n");
					return -1;
				}
				memset(p, 0, MEM_SIZE);
			}
			
			ngx_destroy_pool(pool);
		}
	}
	
	return 0;
}

        程序运行结果如下图：

码农诗人
关注
专栏目录
内存池(MemPool)技术详解
QBox/Golang/CERL/StdExt/TPL/WinxGui - 许式伟的专栏
11-22 3万+
本文已经迁移到： http://cpp.winxgui.com/cn:dive-into-memory-pool概述内存池（MemPool）技术备受推崇。我用google搜索了下，没有找到比较详细的原理性的文章，故此补充一个。另外，补充了boost::pool组件与经典MemPool的差异。同时也描述了MemPool在sgi-stl/stlport中的运用。 经典的内存池技术 
【Nginx 源码学习】内存池 及 优秀案例赏析：Nginx内存池设计(1)
hnsgsdsagaaq的博客
04-19 720
引领完成Docker的安装、部署、管理和扩展，让其经历从测试到生产的整个开发生命周期，深入了解Docker适用于什么场景。并且这本Docker的学习权威指南介绍了其组件的基础知识，然后用Docker构建容器和服务来完成各种任务：利用Docker为新项目建立测试环境，演示如何使用持续集成的工作流集成Docker，如何构建应用程序服务和平台，如何使用Docker的API，如何扩展Docker。
内存池的实现(一)
weixin_34077371的博客
08-31 203
引言 C/C++下内存管理是让几乎每一个程序员头疼的问题，分配足够的内存、追踪内存的分配、在不需要的时候释放内存——这个任务相当复杂。而直接使用系统调用malloc/free、new/delete进行内存分配和释放，有以下弊端： 调用malloc/new,系统需要根据“最先匹配”、“最优匹配”或其他算法在内存空闲块表中查找一块空闲内存，调用free/delete,系统可能需要合并空闲内存块...
内存池的简单设计案例源码(含线程锁)
欧特GO
11-26 1001
头文件 MemoryPools.h #pragma once //尝试开发一个内存池，用于内存管理。 #include <stdio.h> #include <stdlib.h> #include "ThreadLock.h" #define MAX_MEMORYHEAD_SIZE 12 //4个字节的指针块地址 + 4个字节的链表首地址 + 4位验证码 #define MAGIC_CODE 0x123456 //验证码 #define
内存池简单实例
lilianjie001的专栏
12-26 378
#include stdlib.h> #include stdio.h> #include time.h> #include iostream> using namespace std; class MemPool {   public:      MemPool();      ~MemPool();      void* Alloc();      void Fr
一个简单的内存池实现的例子
aican_yu的专栏
11-08 749
前几篇文章对内存池做了两次改进和简化，因为在liunux上内存分配的malloc已经在系统的优化控制范围内了，所以一定范围内的内存分配还是交由系 统比较快，经测试基本上对于大于256字节的内存分配交由本内存池分配性能有明显提高，本次系统所有其他的对象都是构建在这个内存池之上，内存池会对用户 申请的内存作出二次归类管理 代码如下： memeory.h /*  * File:   me
连接池案例 连接池案例
11-25
1. 内存占用：连接池需要占用一定的内存来存储连接，过多的连接可能导致资源浪费。 2. 配置复杂：合理设置连接池参数（如最大连接数、最小连接数、超时时间等）需要经验，配置不当可能影响性能。 常见的连接池实现...
C++ 实现高性能内存池项目实现
yx5666的博客
10-24 641
本节我们实现了一个用于测试性能比较的模板链表栈，目前的代码如下。在下一节中，我们开始详细实现我们的高性能内存池。{T data;};// T 为存储的对象类型, Alloc 为使用的分配器,// 并默认使用 std::allocator 作为对象的分配器{public:// 使用 typedef 简化类型名// 默认构造}// 默认析构}// 当栈中元素为空时返回 true}// 释放栈中元素的所有内存= 0){curr = tmp;}head_ = 0。
【Nginx 源码学习】内存池 及 优秀案例赏析：Nginx内存池设计
2401_84048832的博客
04-18 418
我个人认为，如果你想靠着背面试题来获得心仪的offer，用癞蛤蟆想吃天鹅肉形容完全不过分。想必大家能感受到面试越来越难，想找到心仪的工作也是越来越难，高薪工作羡慕不来，却又对自己目前的薪资不太满意，工作几年甚至连一个应届生的薪资都比不上，终究是错付了，错付了自己没有去提升技术。这些面试题分享给大家的目的，其实是希望大家通过大厂面试题分析自己的技术栈，给自己梳理一个更加明确的学习方向，当你准备好去面试大厂，你心里有底，大概知道面试官会问多广，多深，避免面试的时候一问三不知。
一个简单的内存池一个简单的内存池
08-12
在本案例中，“一个简单的内存池”旨在实现一个基本的内存池框架，用于管理内存的分配和回收。 #### 二、内存池结构设计 1. **内存池节点（`MemStr`）**： - `__int32 InUse;`：表示该内存块是否正在使用。取值...
内存池例子-有代码和解析
04-09
内存池的详细设计说明，有代码和解析 简单的内存池的实现
内存池简单实现（一）
Hi, Boy
08-08 8475
概念 内存池就是在程序启动时，预先向堆中申请一部分内存，交给一个管理对象。在程序运行中，需要时向管理对象“借”，不需要时“还”给管理对象。 原理很简单，关键是怎样才能高效地“借”、“还”。 实例场景 在C/S服务器中，需要频繁地收发数据包。而数据包的内存采用原始的new-delete模式，会大大降低服务器性能，所以想到了使用内存池技术。 在此实例中有几个硬性条件： 1、数据包最大长度可...
写个内存池的代码
weixin_42599908的博客
01-09 63
内存池是一种常用的内存分配机制，它可以有效地管理内存分配和回收。 内存池的基本原理是，在程序运行时，先将一块固定大小的内存分配给内存池，然后在程序中需要分配内存的时候，就从内存池中申请内存。当程序使用完该内存块后，会将其归还给内存池，供其他部分使用。这样，就可以避免频繁地调用系统内存分配函数，提高程序效率。 下面是一个简单的内存池的代码示例，使用 C 语言实现： ``` #include <...
简单内存池的C实现
遇见你是我最美丽的意外
07-19 4572
1. 序言 对于程序开发人员来说，会经常听到这种“池”的概念，例如“进程池”，“线程池”，“内存池”等，虽然很多时没有吃过肉，但是总是见到它跑。上周由于需要性能调优，因此就尝试使用内存池的方式来分配空间，从而提供效率的问题。 网上有各种很优秀的通用的内存池的实现代码：可以调整内存池大小，支持多种大小的内存池，支持调整分配空间大小等等，这种实现是比较完整的实现，但是它针对整个工程或者项目而言是很好的选择。如果我们的需求很是单一，只是想提高某一特定的性能，需要的空间也是固定大小，那么我们就没有必要使用那么优秀复
内存池
abel__2008的专栏
09-25 866
内存池<!--document.write(打印本页);//--><!--document.write(将此页作为电子邮件发送);//-->将此页作为电子邮件发送未显示需要 JavaScr
[RTT例程练习] 3.3 静态内存管理，内存池mempool
weixin_30505225的博客
04-07 211
内存池是一种静态的内存管理方法。它预先将一块固定连续的内存区域划分成几个大小不同的块。使用者申请时就将对应大小的内存块给他。这种方法的优点是不会有内存碎片，但不够灵活，适用于需要频繁存取的场合，例如buffer。 这个例子有两个线程。thread1不停分配内存块，但其中并没有使用delay() 来使自己挂起，所以thread2 由于优先级低于 thread1 而一直得不到运行。threa...
内存池设计与实现
热门推荐
shawn的专栏
06-29 7万+
1. 内存池设计1.1 目的 在给定的内存buffer上建立内存管理机制，根据用户需求从该buffer上分配内存或者将已经分配的内存释放回buffer中。1.2 要求 尽量减少内存碎片，平均效率高于C语言的malloc和free。1.3 设计思路 将buffer分为四部分，第1部分是mem_pool结构体；第2部分是内存映射表；第3部分是内存chunk结构体缓冲区；第4部分
简单内存池实例(C++版)
zhangzhenghe的专栏
03-31 2370
经典的内存池(mempool)技术，是一种用于分配大量大小相同的小对象的技术。通过该技术可以极大加快内存分配/释放过程。内存池只涉及两个静态常量：Block_Size(mempool的容量大小)、Item_Size（小对象的大小，但不能小于指针的大小，在32位平台也就是不能小于4字节），以及两个指针变量BlockNodeHead、FreeItemNodeHead。开始，这两个指针均为空。
stays mad 反PCL宣传库。Anti PCL pro.zip
最新发布
10-31
stays mad 反PCL宣传库。Anti PCL pro
Apache内存池原理与管理
Apache内存池的设计思想和实现细节是C/C++编程中优化内存管理的一个经典案例，对于理解和解决大规模系统中的内存问题具有重要的参考价值。通过深入理解内存池的工作原理，开发者能够更有效地管理内存，提升应用程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值