基于C语言的内存池实现

【池化技术】内存池技术原理和C语言实现 文章目录一、基础概念1.一个可执行程序占用的内存分为哪几个区?一个进程的虚拟内存区域有哪些?2.静态内存分配和动态内存分配二、malloc实现原理malloc内存分配(下面算是正常一般的情况了)三、使用C语言实现一个内存池1.C语言实现一个内存池 一、基础概念 在讲内存池技术之前,咱们先对一些基础概念进行阐述,以便能更好的讨论问题。 1.一个可执行程序占用的内存分为哪几个区?一个进程的虚拟内存区域有哪些? C语言在内存中一共分为如下几个区域,分别是: 内存栈区(stack): 存放局部变量名; 内存 阅读详情

前言

1、池化技术 :简单点来说,就是提前保存大量的资源,以备不时之需

        对于线程,内存,oracle的连接对象等等,这些都是资源,程序中当你创建一个线程或者在堆上申请一块内存时,都涉及到很多系统调用,也是非常消耗CPU的,如果你的程序需要很多类似的工作线程或者需要频繁的申请释放小块内存,如果没有在这方面进行优化,那很有可能这部分代码将会成为影响你整个程序性能的瓶颈。

池化技术主要有线程池,内存池,连接池,对象池等等。

一、内存池

1、内存池原理

        内存池(Memory pool)提供了一种比较可行的解决方案。首先是创建内存池。这个过程的主要任务是预先分配足够大的内存,形成一个初步的“内存池”。分配内存,也就是用户请求内存时,会返回内存池中一块空闲的内存,并将其标志置为已使用,当然具体细节和方法有很多。释放内存时,不是真正地调用free或是delete的过程,而是把内存放回内存池的过程。在把内存放入内存池的同时,要把标志位置为空闲。最后在应用程序结束时,要把内存池销毁。这里主要做的工作就是把内存池中的每一块内存释放。

2、使用内存池的好处

        设计内存池的目标是为了保证代码长时间高效的运行,通过对申请空间小而申请频繁的对象进行有效管理,减少内存碎片的产生,合理分配管理用户内存,从而减少系统中出现有效空间足够,而无法分配大块连续内存的情况。

  • 减少了内存碎片的产生。这个可以从创建内存池的过程中看出。我们在创建内存池时,分配的都是一块块比较整的内存块,这样可以减少内存碎片的产生;
  • 提高了内存的使用效率。这个可以从分配内存和释放内存的过程中看出。每次的分配与释放并不是去调用系统提供的函数或是操作符去操作实际的内存,而是在复用内存池中的内存。

3、缺点

就是很有可能会造成内存的浪费,原因也很明显,开始分配了一大块内存,不是全部都用得到的。

4、内存池的代码实现

内存池代码实现原理图

 4.1、内存池结构体

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>

#define MP_ALIGNMENT       		32		//对齐大小
#define MP_PAGE_SIZE			4096	//内存池小块大小
#define MP_MAX_ALLOC_FROM_POOL	(MP_PAGE_SIZE-1)

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

typedef struct mp_large_s {
	struct mp_large_s *next;    //下一块 内存大块
	void *alloc;                //内存大块的地址
}mp_large_t;

typedef struct mp_node_s {

	unsigned char *last;        //当前 内存小块已分配的地址
	unsigned char *end;         //内存小块 末尾地址
	
	struct mp_node_s *next;     //指向下一块 内存小块
	size_t failed;              //5次访问节点还是不可以分配空间就访问下一个节点
}mp_node_t;

typedef struct mp_pool_s {

	size_t max;				// 小块内存 的最大值

	mp_node_t *current;		//指向当前可分配的 内存小块
	mp_large_t *large;      //指向 内存大块

	mp_node_t head[0];      //内存小块 开始分配的地址

}mp_pool_t;

4.2 内存池函数封装

mp_pool_t *mp_create_pool(size_t size);            //内存池创建
void mp_destory_pool(mp_pool_t *pool);             //内存池删除
void *mp_alloc(mp_pool_t *pool, size_t size);      //内存池分配
void *mp_nalloc(mp_pool_t *pool, size_t size);     //内存池分配
void *mp_calloc(mp_pool_t *pool, size_t size);     //内存池分配
void mp_free(mp_pool_t *pool, void *p);            //内存池释放
void mp_reset_pool(mp_pool_t *pool) ;              //内存池重置

4.3 内存池测试代码

mp_pool_t *mp_create_pool(size_t size) {

	mp_pool_t *p;
	int ret = posix_memalign((void **)&p, MP_ALIGNMENT, size + sizeof(mp_pool_t) + sizeof(mp_node_t));
	if (ret) {
		return NULL;
	}
	
	//
	p->max = (size < MP_MAX_ALLOC_FROM_POOL) ? size : MP_MAX_ALLOC_FROM_POOL;
	p->current = p->head;
	p->large = NULL;

	p->head->last = (unsigned char *)p + sizeof(mp_pool_t) + sizeof(mp_node_t);
	p->head->end = p->head->last + size;

	p->head->failed = 0;

	return p;

}

void mp_destory_pool(mp_pool_t *pool) {

	mp_node_t *h, *n;
	mp_large_t *l;

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

	h = pool->head->next;

	while (h) {
		n = h->next;
		free(h);
		h = n;
	}

	free(pool);

}

//内存池重置 释放large 将node节点last重置
void mp_reset_pool(mp_pool_t *pool) {

	mp_node_t *h;
	mp_large_t *l;

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

	pool->large = NULL;

	for (h = pool->head; h; h = h->next) {
		h->last = (unsigned char *)h + sizeof(mp_node_t);
	}

}

//内存池小块分配
static void *mp_alloc_block(mp_pool_t *pool, size_t size) {

	unsigned char *m;
	mp_node_t *h = pool->head;
	size_t psize = (size_t)(h->end - (unsigned char *)h);
	
	int ret = posix_memalign((void **)&m, MP_ALIGNMENT, psize);
	if (ret) return NULL;

	mp_node_t *p, *new_node, *current;
	new_node = (mp_node_t*)m;

	new_node->end = m + psize;
	new_node->next = NULL;
	new_node->failed = 0;

	m += sizeof(mp_node_t);
	m = mp_align_ptr(m, MP_ALIGNMENT);
	new_node->last = m + size;

	current = pool->current;

	for (p = current; p->next; p = p->next) {
		if (p->failed++ > 4) { //
			current = p->next;
		}
	}
	p->next = new_node;

	pool->current = current ? current : new_node;

	return m;

}

//内存池大块分配
static void *mp_alloc_large(mp_pool_t *pool, size_t size) {

	void *p = malloc(size);
	if (p == NULL) return NULL;

	size_t n = 0;
	mp_large_t *large;
	for (large = pool->large; large; large = large->next) {
		if (large->alloc == NULL) {
			large->alloc = p;
			return p;
		}
		if (n ++ > 3) break;
	}

	large = mp_alloc(pool, sizeof(mp_large_t));
	if (large == NULL) {
		free(p);
		return NULL;
	}

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

	return p;
}

void *mp_memalign(mp_pool_t *pool, size_t size, size_t alignment) {

	void *p;
	
	int ret = posix_memalign(&p, alignment, size);
	if (ret) {
		return NULL;
	}

	mp_large_t *large = mp_alloc(pool, sizeof(mp_large_t));
	if (large == NULL) {
		free(p);
		return NULL;
	}

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

	return p;
}

void *mp_alloc(mp_pool_t *pool, size_t size) {

	unsigned char *m;
	mp_node_t *p;

	if (size <= pool->max) {

		p = pool->current;

		do {
			
			m = mp_align_ptr(p->last, MP_ALIGNMENT);
			if ((size_t)(p->end - m) >= size) {
				p->last = m + size;
				return m;
			}
			p = p->next;
		} while (p);

		return mp_alloc_block(pool, size);
	}

	return mp_alloc_large(pool, size);
	
}


void *mp_nalloc(mp_pool_t *pool, size_t size) {

	unsigned char *m;
	mp_node_t *p;

	if (size <= pool->max) {
		p = pool->current;

		do {
			m = p->last;
			if ((size_t)(p->end - m) >= size) {
				p->last = m+size;
				return m;
			}
			p = p->next;
		} while (p);

		return mp_alloc_block(pool, size);
	}

	return mp_alloc_large(pool, size);
	
}

void *mp_calloc(mp_pool_t *pool, size_t size) {

	void *p = mp_alloc(pool, size);
	if (p) {
		memset(p, 0, size);
	}

	return p;
	
}

void mp_free(mp_pool_t *pool, void *p) {

	mp_large_t *l;
	for (l = pool->large; l; l = l->next) {
		if (p == l->alloc) {
			free(l->alloc);
			l->alloc = NULL;

			return ;
		}
	}
	
}


int main(int argc, char *argv[]) {

	int size = 1 << 12;
	int size1 = 1 << 3;
	int size2 = 1 << 6;
	int size3 = 1 << 9;
	mp_pool_t *p = mp_create_pool(size);

	int i = 0;
	for (i = 0;i < 10;i ++) {

		void *mp = mp_alloc(p, 512);
//		mp_free(mp);
	}

	//printf("mp_create_pool: %ld\n", p->max);
	printf("mp_align(123, 32): %d, mp_align(17, 32): %d\n", mp_align(24, 32), mp_align(17, 32));
	//printf("mp_align_ptr(p->current, 32): %lx, p->current: %lx, mp_align(p->large, 32): %lx, p->large: %lx\n", mp_align_ptr(p->current, 32), p->current, mp_align_ptr(p->large, 32), p->large);

	int j = 0;
	for (i = 0;i < 5;i ++) {

		char *pp = mp_calloc(p, 32);
		for (j = 0;j < 32;j ++) {
			if (pp[j]) {
				printf("calloc wrong\n");
			}
			printf("calloc success\n");
		}
	}

	//printf("mp_reset_pool\n");

	for (i = 0;i < 5;i ++) {
		void *l = mp_alloc(p, 8192);
		mp_free(p, l);
	}

	mp_reset_pool(p);

	//printf("mp_destory_pool\n");
	for (i = 0;i < 58;i ++) {
		mp_alloc(p, 256);
	}

	mp_destory_pool(p);

	return 0;

}

5、内存池库tcmalloc的使用

5.1 tcmalloc安装

        tcmalloc在gperftools之中,故想要使用tcmalloc,就得先安装gperftools。在linux下,其安装步骤如下:

去github官网下载: http://​ https://github.com/gperftools/gperftools.git ​ gperftools-master.zip

环境配置:

编译环境:Ubuntu 

编译器:arm-fsl-linux-gnueabi

指定安装路径:/home/thunder/Downloads/gperftools-master/build

cd gperftools-master

./autogen.sh 

默认安装

./configure --enable-frame-pointers

指定安装

./configure --prefix=/home/thunder/Downloads/gperftools-master/build --host=arm-fsl-linux-gnueabi --enable-frame-pointers

sudo make

sudo make install

执行上面命令后会生成下面4个文件

 5.2 tcmalloc的使用

只要在编译代码时添加 -ltcmalloc就可以了。

gcc -o main main.cc -L. -ltcmalloc

这样编译出来的可执行程序main使用的malloc和free将来自tcmalloc。

补充:类似的内存池的库还有Jemalloc

完!

如过文章对您有帮助,请点赞一下吧

4

444内存池池的实现内存池的实现

C语言中的内存池和内存管理技术是什么? 内存池是一种内存管理技术,它是为了提高内存分配和释放的效率而设计的。在传统的内存管理中,每次分配和释放内存都需要与操作系统交互,这涉及到较大的开销。内存池的目标是通过一次性分配一块连续的内存,然后将其划分成小块,以供程序使用,从而减少这种开销。内存分配器(Allocator):内存分配器负责从操作系统中分配一块连续的内存。这块内存通常是较大的,然后内存分配器将其划分成小块,以供程序使用。内存块(Memory Blocks) 阅读详情

相关推荐

C语言实现内存池

什么是内存池,这里简单介绍一下(不做详细说明),内存池技术是一种用于分配大量大小相同的小对象的技术,通过该技术可以极大加快内存分配/释放过 程。其原理是先申请一大块内存,然后分成若干个大小相等的小块,用链表的方式将这些小块链在一起,当开发人员需要使用内存时(分配),从链表头取下一块返 回给开发人员使用;当开发人员使用完毕后(释放),再将这块内存重新挂回链表尾。这样操作的好处有如下三点:1、提高分配和释放的效率;2、避免开发人员 忘记释放内存造成内存泄露;3、减少内存占用(频繁的malloc是很占内存空

networkwx的专栏 1万+

内存池 c语言实现

本文旨在纯c实现内存池。根据服务器一个客户端对应一个连接,一个连接对应一个内存池的业务场景实现内存池。

weixin_60208935的博客 3831

各种池---内存池的高效实现(C语言)

序言 在编程过程中,尤其是对于C语言开发者,其实编程就是在使用内存,不停地变化内存中的数据。当我们想开辟一片新的内存使用时,就会使用malloc实现。但是通过查阅很多资料,发现频繁的使用malloc并不是很好的选择。原因就是如果频繁的申请内存、释放内存,操作系统由于内存管理算法原因,导致会出现内存碎片。其实产生碎片是一件很平常的事情,为何会这样,我想主要是内存利用率与性能的一个平衡。如果操作系统

forever5312的专栏 2万+

c语言实现的内存池(适用于两个线程、不加锁、效率高)

设计一个内存池,要求效率比系统调用的效率要高(测试1万次),同时支持一个线程申请,另外一个线程释放。

weixin_47342627的博客 553

C语言使用libpq访问PostgresQL数据库

虽然代码中是.cpp文件但其实本质上是C,其实不是原创!只是自己整理下!希望对在学习的朋友提供点帮助 。

Windows中的TLS 1.2启用方法(IIS、C#、.Net framework)

折腾几天了windows中的tls1.2启用方法!特此记录一下 开发背景: 在一个用.net framework 2.0开发的客户端程序里面嵌入功能调用第三方物联网相关接口,服务器上有一个restful接口用于接收第三方上报的数据及处理,最后再调用第三方的物联网相关接口。本机开发环境Windows 10,客户服务器是Windows Server 2008 R2。 第一次写这种物联网相关的接口调用,而且第三方提供的文档比较简单,最基本的报文示例都没。开发环境里面各种摸索一步一个坑,首先在发送HTTP请求前

dl1314ld的博客 1万+

c语言基于mmap实现的内存池

c语言基于mmap实现的内存池模块

Where there is life, there is hope. 947

前端监控性能指标

文章目录前端监控性能指标性能指标阶段性指标关键性能指标小程序W3C Level 1兼容性常规用法注意事项1、计算HTML文档请求使用 Nav Timing2、计算静态资源使用 getEntriesByType('resource') 代替 getEntries()3、secureConnectionStart 问题4、跨域资源设置响应头 Timing-Allow-Origin5、注意属性值为 0 ...

foolbird 1350

内存池的C语言实现

在某些情况下,需要反复申请和释放大量固定大小的小块内存,如果利用malloc和free的话不但效率低下,而且会使系统产生大量的内存碎片。此时,大都选择使用内存池(Memory Pool)来提高效率。内存池的原理就是事先申请好一大块内存,然后再在这块内存上分配和释放小块内存。由于允许申请的内存块大小固定,因此不会产生,也不会有分割合并内存块的开销。下面是我正在编写的GUI系统中所使用的内存池

EricLogic 2349

图像配准(Image Registration)——深度学习方法

参考:https://www.cnblogs.com/carsonzhu/p/11188574.html

m0_46483236的博客 4万+

从STM32转战小华HC32F448:手把手教你搞定串口复用与超时中断(附完整代码)

本文详细介绍了从STM32迁移到小华HC32F448的串口开发实战指南,重点解析了HC32F448的GPIO复用系统和超时中断机制。通过对比STM32的架构差异,提供了完整的串口配置代码和优化方案,帮助开发者快速掌握HC32F448的串口通信技术,适用于工业控制等应用场景。

weixin_30564901的博客 550

基于C语言的内存池的实现

于线程池类似,内存池是一个管理一段连续内存块的池式结构。

lsj2889281818的博客 472

1.4 《SST通用技术规范》整体框架与核心条款解读

本小节以**GB/T《电力电子变压器通用技术要求》**(固态变压器SST核心通用规范)为核心依据,结合电力电子变压器技术特性与工程应用边界,系统解析规范的整体章节框架、层级逻辑与强制性/推荐性核心条款,明确规范与传统工频变压器标准的差异,为SST拓扑设计、性能验证、出厂检验与工程落地提供标准化依据。全文以标准原文、期刊文献数据与试验规范为支撑,无主观推演与感性表述。

技术工作者 1705

C语言实现简单内存池

在用C语言开发时,特别是在服务器端,内存的使用会成为系统性能的一个瓶颈,如频繁的分配和释放内存,会不断的增加系统的内存碎片,影响内核之后分配内存的效率,这个时候一个比较可行的做法是采用内存池,先分配好比较多的内存,然后在这个已经分配的内存里使用内存,这样就不需要内核过多的参与内存分配和释放的过程。 内存池根据应用不同有多种实现的策略,如有些分配很大的内存,然后将内存分配成大小相等的块,并将每个块

欣宇专栏 4477

9篇3章7节:基于 R 语言的 FAERS 数据提取与合并

本文主要探讨了 FAERS 数据提取与合并的操作流程。首先,通过程序化方法从本地存储的 FAERS ASCII 文件中提取指定季度或范围内的单药报告数据,并可通过参数设置控制数据存储位置、处理方式、计算资源分配以及报告者职业类别等。随后,通过批量读取的方式对多个季度的 DRUG 文件进行循环处理,并将其合并为一个综合数据框。

MD Code 1269

uniapp微信小程序开发:解决Video播放m3u8视频流非卡顿问题,使用video视频标签播放M3U8视频流或直播流总是加载一卡一卡的体验非常差的情况【多种优化方案提升流畅度和缓冲方案示例源码】

uniapp微信小程序video播放m3u8视频流卡,uniapp video在微信小程序播放m3u8格式视频总是加载频繁卡顿,Uniapp微信小程序苹果ios真机播放m3u8很卡加载不流畅怎么办,uni-App如何解决小程序端video播放视频流M3U8格式出现卡顿情况,uniapp播放m3u8直播流卡顿如何优化?uniapp m3u8格式视频加载,.m3u8监控视频,uniapp微信小程序使用video组件播放M3U8视频卡顿,uniapp微信小程序视频播放卡顿如何解决,uniapp 打包微信小程序播放

✅ 精选推荐文章 2989

C语言内存池设计与实现

C语言内存池设计与实现1. 内存池设计1.1 目的1.2 设计思路1.3 内存池管理程序运行过程1.4 减少内存碎片2. 源代码MemoryPool.hMemoryPool.cppTest_MemPool.cpp 1. 内存池设计 1.1 目的 在给定的内存buffer上建立内存管理机制,根据用户需求从该buffer上分配内存或者将已经分配的内存释放回buffer中。 尽量减少内存碎片,平均效率高于C语言的malloc和free。 该给定的内存buffer可以有2种设置方式,例如:申请500M的内存bu

zw_whusgg的博客 2341

5.3-集群电源模式解析

DSU-120 DynamIQ™集群支持9种电源模式,包括正常运行(ON)、完全断电(OFF)、三种数据保持模式(FUNC_RET、FULL_RET、MEM_RET)、两种调试模拟模式(OFF_EMU、MEM_RET_EMU),以及系统恢复模式(WARM_RST、DBG_RECOV)。这些模式通过智能管理电源状态,在保持数据完整性的同时实现功耗优化,并为系统调试和故障恢复提供支持。不同模式在RAM保持、逻辑断电和调试能力方面各有侧重,满足从正常运行到深度调试等不同场景需求。

baron-周贺贺-代码改变世界ctw 117

C语言内存池实现

本文提供一种高效内存池的实现方法。该内存池预先调用系统函数malloc申请一大片内存,使用时从该内存池中申请内存,使用完成后释放回内存池,内存块由内存池维护。

m0_48995611的博客 577

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

【池化技术】内存池技术原理和C语言实现_内存池c语言

NULL) //节点开辟不成功\n”);n += 1;//节点总数增加1个if(n == 1) //如果节点总数是1,则head指向刚创建的节点p1//此时的p2就是p1,也就是p1->next指向NULL。else//指向上次下面刚刚开辟的新节点p2 = p1;//把p1的地址给p2保留,然后p1产生新的节点//开辟出新节点\n”,n+1);//开辟出新内存块//链表的最后一个节点指向NULL。

2401_84264107的博客 1569

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

C语言小项目实现简易内存池管理

本文介绍了C语言实现简易内存池管理的设计与实现。主要内容包括:1)内存池初始化,通过malloc/calloc分配连续内存区域;2)内存分配功能,寻找连续空闲块并标记;3)内存释放,计算释放范围并重置状态;4)内存池销毁。设计采用64字节固定块大小,用数组记录分配状态(0空闲/1占用)。关键点包括:地址偏移计算、内存块数向上取整、连续空间查找策略等。文章详细说明了各功能的实现步骤,并强调了错误处理和内存释放的重要性。最后提供了测试建议,鼓励读者实践讨论。该实现可作为理解动态内存管理和指针应用的实践案例。

2301_78764185的博客 1225

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

自实现C语言的内存池

前言 具体什么是内存池,不说了。我也是闲来无聊,自己实现一个内存池,也比较简单。 设计思路 我们采用C语言实现,所以,需要实现一些简单的容器。比如单链表。 总体大概设计思路示意图如上所示。 一个数组(或者向量(我们把原始的C语言数组,称之为数组,把类似的在堆空间中申请来的连续线线性空间称之为向量)),每一个节点是一个链表,每个链表里面挂着元素,元素的data指针便是我们内存池里面放的内存指针。 详细思路 第一:纲领数组我们按照索引,最小比如64,128,256 这样预先定义好。到了足够大之后,比如4k,我

frodocheng的博客 699

【C语言练习】073. 编写代码实现简单的内存池

本文介绍了用C语言实现简单内存池的方法。内存池通过预分配大块内存并内部管理分配,能显著提高频繁小内存分配场景的性能。文章详细展示了内存池的数据结构设计,包含初始化、分配、释放和销毁等核心功能实现代码,并提供了示例运行结果。实现要点包括:使用空闲链表管理可用内存块、基于索引的快速分配与回收机制、以及内存对齐处理等注意事项。这种技术特别适合对性能要求高或需要严格控制内存使用的场景,能有效减少内存碎片和分配开销。

视睿 871

c语言实现内存池

该模型的内存池就是根据实际代码中内存分配的情况,申请多个全局变量当做不同块大小的内存池,每个内存池分割成单一块大小的内存,申请内存的时候根据内存块的大小从最匹配的内存块中获取一块。我们在实际分配内存的时候,因为内存大小不一,采用连续的内存池就是基于一块连续的内存去分配这些大小不一的内存,在回收的时候根据地址要做合并,使用这种内存的好处是配置简单,比较难造成内存浪费,缺点就是性能较差。内存池原理其实很简单,就是使用全局变量申请一块内存,然后基于这些全局变量的内存来进行内存分配和回收。

len_yue_mo_fu的博客 610

C语言实现的内存池

用C语言写了个插件,在第三方服务器上跑。对方基于稳定、安全性等方面的考虑,提出了各种限制条件,其中有一个要求是程序运行期间,只允许申请一次内存空间。逼着只能自己实现一个内存池。 步骤1.程序启动时申请一块内存M; 步骤2.封装malloc函数,该函数实现申请的内存节点都从M内存块中划分; 步骤3.封装free函数,该函数实现将内存节点还给M内存块; 步骤4.为了避免内存节点碎片,释放后的小内存节点需要合并成一块。 相比直接调用malloc,有下面几点优点: 1.提升了性能,相对于malloc调用

oria2006的专栏 599
上一篇: linux中设置NTP(服务端、客户端)时间同步
下一篇: 线程池代码的C实现以及在各种开源框架中的使用
BUG键盘侠
博客等级 码龄6年 75粉丝 22原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值