内存池简单案例

已于 2022-11-30 11:01:02 修改
阅读量685 收藏
点赞数
分类专栏： 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;
}

        程序运行结果如下图：

码农诗人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言经典案例
10-30
本文件中讲述了c语言经典的282个案例，由浅入深。有利于提高广大爱好c语言编程的人员。 其中包括： 第1章 初识C语言 1 实例001 第一个C语言程序 2 实例002 一个完整的C语言程序 2 实例003 输出名言 3 实例004 用TC ...
写个内存池的代码
weixin_42599908的博客
01-09 51
内存池是一种常用的内存分配机制，它可以有效地管理内存分配和回收。 内存池的基本原理是，在程序运行时，先将一块固定大小的内存分配给内存池，然后在程序中需要分配内存的时候，就从内存池中申请内存。当程序使用完该内存块后，会将其归还给内存池，供其他部分使用。这样，就可以避免频繁地调用系统内存分配函数，提高程序效率。 下面是一个简单的内存池的代码示例，使用 C 语言实现： ``` #include <...
内存池的简单设计案例源码(含线程锁)
欧特GO
11-26 939
头文件 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
内存池简单实现（一）
Hi, Boy
08-08 8004
概念 内存池就是在程序启动时，预先向堆中申请一部分内存，交给一个管理对象。在程序运行中，需要时向管理对象“借”，不需要时“还”给管理对象。 原理很简单，关键是怎样才能高效地“借”、“还”。 实例场景 在C/S服务器中，需要频繁地收发数据包。而数据包的内存采用原始的new-delete模式，会大大降低服务器性能，所以想到了使用内存池技术。 在此实例中有几个硬性条件： 1、数据包最大长度可...
内存池
abel__2008的专栏
09-25 774
内存池<!--document.write(打印本页);//--><!--document.write(将此页作为电子邮件发送);//-->将此页作为电子邮件发送未显示需要 JavaScr
内存池简单实例
lilianjie001的专栏
12-26 357
#include stdlib.h> #include stdio.h> #include time.h> #include iostream> using namespace std; class MemPool {   public:      MemPool();      ~MemPool();      void* Alloc();      void Fr
Java案例开发锦集
03-04
案例3 用JDOM解析XML文件 案例4 Java编制的时钟 案例5 简单日历 案例6 系统内存状态监视程序 案例7 简单计算器 案例8 多线程断点续传 案例9 笛卡尔曲线 第四章 Java与游戏 案例1 ...
J2EE经典案例设计与实现
12-13
案例5：J2EE访问Tomcat中的数据连接池 案例6：J2EE访问JBoss中数据连接池 案例7：J2EE访问WebLogic中的数据连接池 案例8：简单的登录程序 案例9：数据分页显示 案例10：网上投票系统 案例11：在浏览器内运行SQL命令 ...
UnityGameFramework案例源码.zip
05-31
UnityGameFramework案例源码，包括： 主要对游戏开发过程中常用模块进行了封装，很大程度地规范开发过程、加快开发速度并保证产品质量，是一个重度化的Unity游戏框架。 在最新的 Game Framework 版本中，包含以下 ...
Java-web旅游项目实战案例（四个）IDEA项目源码
08-15
Java-web旅游项目实战案例（四个）IDEA项目源码； 4 技术选型 4.1 Web层 a) Servlet：前端控制器 b) html：视图 c) Filter：过滤器 d) BeanUtils：数据封装 e) Jackson：json序列化工具 4.2 Service层 f) Javamail：...
内存池例子-有代码和解析
04-09
内存池的详细设计说明，有代码和解析 简单的内存池的实现
内存池(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中的运用。 经典的内存池技术 
[RTT例程练习] 3.3 静态内存管理，内存池mempool
weixin_30505225的博客
04-07 195
内存池是一种静态的内存管理方法。它预先将一块固定连续的内存区域划分成几个大小不同的块。使用者申请时就将对应大小的内存块给他。这种方法的优点是不会有内存碎片，但不够灵活，适用于需要频繁存取的场合，例如buffer。 这个例子有两个线程。thread1不停分配内存块，但其中并没有使用delay() 来使自己挂起，所以thread2 由于优先级低于 thread1 而一直得不到运行。threa...
一个简单的内存池实现的例子
aican_yu的专栏
11-08 691
前几篇文章对内存池做了两次改进和简化，因为在liunux上内存分配的malloc已经在系统的优化控制范围内了，所以一定范围内的内存分配还是交由系 统比较快，经测试基本上对于大于256字节的内存分配交由本内存池分配性能有明显提高，本次系统所有其他的对象都是构建在这个内存池之上，内存池会对用户 申请的内存作出二次归类管理 代码如下： memeory.h /*  * File:   me
内存池设计与实现
热门推荐
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部分
Markdown学习笔记
04-30
Markdown学习笔记
热塑性弹性体，全球前21强生产商排名及市场份额.docx
04-30
热塑性弹性体，全球前21强生产商排名及市场份额
配合eclipse svn插件subclipse-4.3.4版本的javahl
04-30
配合eclipse svn插件subclipse-4.3.4版本的javahl，将其中的features和plugins目录解压到与subclipse-4.3.4插件同一目录下即可。在eclipse 4.31版本上验证有效。
一个基于epoll的多线程 linux c http web服务器.zip
最新发布
04-30
一个基于epoll的多线程 linux c http web服务器.zip
threadlocal内存泄露案例
07-31
ThreadLocal是Java中的一个工具类，主要用于保持线程间的数据隔离。然而，不正确地使用ThreadLocal可能导致内存泄漏。 内存泄漏是指在程序中使用的内存无法被垃圾回收机制回收，导致内存占用不断增加。ThreadLocal的内存泄漏案例如下： 1. 长生命周期的ThreadLocal对象：如果一个ThreadLocal对象的生命周期比应用程序还长，导致ThreadLocal所持有的value对象无法被释放。此时，即使ThreadLocal对象已不再被调用，value对象仍然在ThreadLocalMap中存在，并且无法被垃圾回收，导致内存泄漏。 2. 线程池的ThreadLocal未清理：在使用线程池的环境下，如果某个线程绑定了一个ThreadLocal对象，而未在任务执行结束后手动清除绑定的值，那么该ThreadLocal对象将一直存在于线程池中。如果线程池中的线程数量非常大，将会导致大量ThreadLocal对象未被释放，从而造成内存泄漏。 3. 循环引用：当ThreadLocal对象和其它对象之间存在循环引用关系时，也会导致内存泄漏。因为ThreadLocalMap中的Entry是弱引用，但如果ThreadLocal对象本身被其它对象强引用，就会导致ThreadLocalMap中的Entry无法被清理，从而造成内存泄漏。 为避免ThreadLocal内存泄漏，应注意以下几点： 1. 及时清理ThreadLocal对象：使用完ThreadLocal对象后，应手动调用其remove()方法，确保对应的value对象能够被释放。 2. 避免长生命周期的ThreadLocal对象：尽量将ThreadLocal对象定义为局部变量，而非静态变量或全局变量。 3. 线程池中使用ThreadLocal的安全清理：在使用线程池时，确保在任务执行结束后及时清理线程中绑定的ThreadLocal对象。 4. 避免循环引用：注意ThreadLocal对象与其它对象之间的引用关系，避免产生循环引用。 总而言之，ThreadLocal内存泄漏是由于一些使用不当造成的，合理使用ThreadLocal并进行正确的清理操作，能避免内存泄漏问题的发生。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值