使用自定义堆，代替系统缺省堆？

已于 2022-05-04 07:00:53 修改
阅读量245 收藏
点赞数
文章标签： 数据结构
于 2022-05-04 00:54:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/thomastsm/article/details/124564534
版权

前一篇文章追踪heap使用，检测内存泄漏？既然没有解决问题（上一篇主要是帮助发现问题），那么能不能避开缺省堆呢，使用自己管理的堆，调用接口又能完全兼容呢？于是，有了如下想法：
1. 使用一大段全局区作为自定义的堆（代码中的g_heap[MAX_HEAP_SIZE]），所有的堆分配请求，和用于堆管理的内存（HEAP_BLOCK）都使用这段内存。
2. 将这一大段区域，处理成HEAP_BLOCK为结点的双向链表，每个结点HEAP_BLOCK要么处于已分配状态（ALLOCATED），要么可分配状态（FREE），每个结点还包含内存大小等信息，具体见HEAP_BLOCK定义。注意：为了避免使用系统缺省堆，结点在自定义heap区域是依次连续的，只是结点状态和内存大小会随着分配和释放不停变化。初始状态下，整个自定义heap区域被视为一个FREE态的HEAP_BLOCK。
3. 分配请求的处理：在链表中寻找第一个未分配且buff足够大的HEAP_BLOCK，如找到就进行分配（即1个FREE的HEAP_BLOCK可能分裂成1个ALLOCATED的HEAP_BLOCK和1个FREE的HEAP_BLOCK）；如果没找到，先尝试合并连续的FREE态的HEAP_BLOCK（即将多个连续的FREE态HEAP_BLOCK合并成一个大的FREE态HEAP_BLOCK）。
4. 释放请求的处理：根据传入的地址，将对应的HEAP_BLOCK标记为FREE。
5. 已考虑：统计自定义堆的内存使用峰值，避免多个很小的FREE态HEAP_BLOCK(避免太多内存碎片)，等等，具体见代码。
6. 未考虑：线程安全；已尽可能考虑数据大小溢出的问题。
以下是代码（macro USE_MY_HEAP包含的是本文描述的内容，macro USE_SYS_HEAP_TRACK包含的是上一篇文章描述的内容)，和遇到问题的简单总结。


完整的头文件的内容如下（heap_wrapper.h）:
 

#pragma once

#define USE_MY_HEAP               //use the heap implemented based on a big range of global data
//#define USE_SYS_HEAP_TRACK        //use the system heap and we track the heap usage
//#define USE_SYS_HEAP_NO_TRACK     //just the system heap


#if defined(USE_MY_HEAP)
void * custom_calloc(uint32_t num, uint32_t size, const char* function_name, uint32_t line_num);
void custom_free(void* ptr);
void print_heap_info();

#define NEW_CALLOC(num,size)  custom_calloc(num,size,__FUNCTION__,__LINE__)
#define NEW_FREE(ptr)         custom_free(ptr)
#define PRINT_HEAP_INFO()     print_heap_info()
#endif

#if defined(USE_SYS_HEAP_TRACK)
void * custom_calloc(uint32_t num, uint32_t size, const char* function_name, uint32_t line_num);
void custom_free(void* ptr);
void print_heap_info();

#define NEW_CALLOC(num,size)  custom_calloc(num,size,__FUNCTION__,__LINE__)
#define NEW_FREE(ptr)         custom_free(ptr)
#define PRINT_HEAP_INFO()     print_heap_info()
#endif

#if defined(USE_SYS_HEAP_NO_TRACK)
#define NEW_CALLOC            calloc
#define NEW_FREE              free
#define PRINT_HEAP_INFO()     print_heap_info()
#endif

完整的源代码文件如下（heap_wrapper.c）：
 

#include "heap_wrapper.h"

#if defined(USE_MY_HEAP)
//use a big range of global area as the heap
//all heap request from callers and heap management is based on it

//the global heap area is a list of blocks, either in allocated state (used for a heap memory request)  or free state(not used and available for request)
//each block begins with a fixed-size block information (state, start/size, function_name/line_num, next/previous) and a variable buffer (specified by start/size in block information)

//initially, the whole heap area is one block of free area

//Process a calloc request:
//step 1: search the first free block that is big enough, 
//step 2: if found, 
//step 2.1: do the allocation: that is 1 free block changed into 1 allocated block and 1 free block(if more bytes left)
//Step 2.2: inserted the 2 new blocks into the list to replace the original one
//Step 3:  if not found, merge the continous free blocks: multiple continous free block are replaced with 1 big free block in the list, goto step 1 and try again

//Process a free request:
//per the input address, find the block in the list and mark it as free

//limitation not thread safe



//if after a allocate request, the left memory is not big enough, not to mark it as a new free block
//to avoid too many small free blocks
#define MIN_BLOCK_AVAILABLE_BUFF_SIZE   (32)   
#define MAX_HEAP_SIZE                   (2*1024*1024)  //2MB

#dfine MAX_FUNCTION_NAME_LEN            (32)
static char    g_function_name[MAX_FUNCTION_NAME_LEN] = "unkown";
static uint8_t g_heap[MAX_HEAP_SIZE];

typedef enum _HEAP_BLOCK_STATE_
{
	HEAP_BLOCK_FREE = 0,
	HEAP_BLOCK_ALLOCATED,
}HEAP_BLOCK_STATE;

typedef struct _HEAP_BLOCK_ HEAP_BLOCK, *PHEAP_BLOCK;
typedef struct _HEAP_BLOCK_
{
	HEAP_BLOCK_STATE state;
	void*            start;       //start of buffer for caller's request (not including this HEAP_BLOCK)
	uint32_t         size;        //buffer size available for caller's request (not including this HEAP_BLOCK)
	uint32_t         line_num;
	char             function_name[MAX_FUNCTION_NAME_LEN];   //NOTE: trunc it if too long
	PHEAP_BLOCK      next;
	PHEAP_BLOCK      previous;	
}HEAP_BLOCK, *PHEAP_BLOCK; 

typedef struct _HEAP_CONTEXT_
{
	uint64_t heap_size;          //size of all the reserved heap memory
	uint64_t peak_size;          //peak size of all the requests from callers
	uint64_t total_alloc_size;   //current allocated size from callers
	uint32_t total_alloc_count;  //increment for every request, decrement for every free
	uint32_t total_unexpected;   //tracking unexpected cases
	uint32_t total_merge_count; //count of merging continous free areas
	PHEAP_BLOCK head;
	PHEAP_BLOCK tail;	
}HEAP_CONTEXT;

static HEAP_CONTEXT g_heap_context;

//initially, the whole heap area is one block of free area
static void init_heap_context()
{
	if(NULL == g_heap_context.head)
	{
		PHEAP_BLOCK first_block = (PHEAP_BLOCK)g_heap;
		memset(first_block, 0, sizeof(HEAP_BLOCK));
		first_block->state = HEAP_BLOCK_FREE;
		first_block->start = (uint8_t*)first_block + sizeof(HEAP_BLOCK);
		first_block->size = (uint32_t)(sizeof(g_heap) - sizeof(HEAP_BLOCK));
		
		//populate the g_heap_context
		memset(&g_heap_context, 0, sizeof(g_heap_context));
		g_heap_context.heap_size = (uint64_t)sizeof(g_heap);
		g_heap_context.head = first_block;
		g_heap_context.tail = first_block;
	}
}

//merge the continous free blocks: multiple continous free block are replaced with 1 big free block in the list
static void merge_continuous_free_block()
{
	PHEAP_BLOCK free_block = NULL;            //first free block found
	PHEAP_BLOCK next_allocated_block = NULL;  //next allocated block after <free_block> in the list, 
	PHEAP_BLOCK temp = NULL;
	uint32_t total_size = 0;
	uint8_t  meet_merge_condition = 0;
	if(g_heap_context.head)
	{
		free_block = g_heap_context.head;
		while(free_block)
		{
			while(free_block && (HEAP_BLOCK_FREE != free_block.state))  //to find the free block
			{
				free_block = free_block.next;
			}
			
			if(free_block)  //found a free block, then to find next allocated block
			{
				next_allocated_block = free_block.next;
				while(next_allocated_block && (HEAP_BLOCK_ALLOCATED != next_allocated_block.state)) //to find the allocated block
				{
					next_allocated_block = next_allocated_block->next;
				}
				
				//merge condition: more than 1 free blocks (including <free_block>), multiple free blocks in the end of list
				//merge condition: more than 1 free blocks (including <free_block>) | allocated block
				meet_merge_condition = 0;
				if(NULL == next_allocated_block && NULL != free_block->next)
				{
					meet_merge_condition = 1;
				}
				if((NULL != next_allocated_block) && (next_allocated_block != free_block->next))  //not the merge condition
				{
					meet_merge_condition = 1;
				}
				
		        if(!meet_merge_condition)  //not the merge condition
				{
					free_block = next_allocated_block;
					continue;
				}
				else  //meet the merge condition: from <free_block> to revious of <next_allocated_block> (could be NULL) to merge into 1 big free block
				{
					temp = free_block;
					total_size = 0;
					
					//calc the total size
					while(temp->next != next_allocated_block)
					{
						total_size += (sizeof(HEAP_BLOCK) + temp->size);
						temp = temp->next;
					}
					
					free_block->size = total_size - sizeof(HEAP_BLOCK);
					free_block->next = next_allocated_block;
					//no changes to other fields
					memset(free_block->start, 0, free_block->size);
					
					if(NULL != next_allocated_block)
					{
						next_allocated_block->previous = free_block;						
					}
					else
					{
						g_heap_context.tail = free_block;
					}
					
					free_block = next_allocated_block;
					g_heap_context.total_merge_count++;					
				}				
			}
		}
	}
}

void * custom_calloc(uint32_t num, uint32_t size, const char* function_name, uint32_t line_num)
{
	void* ret_addr = NULL;
	uint32_t request_size = num * size;
	uint32_t temp_available_size = 0;
	uint32_t merge_count = 0;
	uint8_t  retried_flag = 0;
	PHEAP_BLOCK temp_block = NULL;
	PHEAP_BLOCK new_block = NULL;
	char* func_name = NULL;
	
	if(request_size <= 0 || request_size > sizeof(g_heap))
	{
		LOGD("heap input wrong size %d", request_size);
		return NULL;
	}
	
	if(NULL == g_heap_context.head)
	{
		init_heap_context();
	}
	
	func_name = (char*)function_name;
	if(NULL == func_name)
	{
		func_name = g_function_name;
	}
	
	LOGD("heap input size %d, %s:%d", request_size, func_name, line_num);
	
try_again:
     
	//search the first free block that is big enough
	temp_block = g_heap_context.head;
	while(temp_block)
	{
		if((HEAP_BLOCK_FREE == temp_block->state) && (temp_block->size >= request_size))
		{
			break;
		}
		else
		{
			temp_block = temp_block->next;
		}
	}
	
	//if not found, merge the continous free blocks: multiple continous free block are replaced with 1 big free block in the list, goto step 1 and try again
	if(NULL == temp_block)
	{
		if(0 == retried_flag)
		{
			retried_flag = 1;
			g_heap_context.total_unexpected++;
			merge_count = g_heap_context.total_merge_count;
			merge_continuous_free_block();
			if(merge_count != g_heap_context.total_merge_count)
			{
				goto try_again;	
			}
		}
	}
	else
	{
		//step 2.1: do the allocation: that is 1 free block changed into 1 allocated block and 1 free block(if more bytes left)
		//Step 2.2: inserted the 2 new blocks into the list to replace the original one
		//big enough but not too much, not split it
		if(temp_block->size < (request_size + sizeof(HEAP_BLOCK) + MIN_BLOCK_AVAILABLE_BUFF_SIZE))  //NOTE: this is to avoid too many small free blocks
		{
			ret_addr = temp_block->start;
			temp_block->state = HEAP_BLOCK_ALLOCATED;
			//temp_block->size not changed  //the whold block is allocated and no new free block generated
			temp_block->line_num = line_num;
			strncpy(temp_block->function_name, func_name, sizeof(temp_block->function_name));
		}
		else  //big enough and too much, split into 2
		{
			ret_addr = temp_block->start;
			temp_available_size = temp_block->size;   //split into request_size | new_block | available size of new_block
			
			//first block of the 2
			temp_block->state = HEAP_BLOCK_ALLOCATED;
			//temp_block->start   //not changed
			temp_block->size = request_size;
			temp_block->line_num = line_num;
			strncpy(temp_block->function_name, func_name, sizeof(temp_block->function_name));
			
			//second block of the 2
			new_block = (PHEAP_BLOCK)((uint8_t*)temp_block->start + temp_block->size);
			new_block->state = HEAP_BLOCK_FREE;
			new_block->start = (uint8_t*)new_block + sizeof(HEAP_BLOCK);
			new_block->size = temp_available_size - request_size - sizeof(HEAP_BLOCK);
			new_block->next = temp_block->next;
			new_block->previous = temp_block;
			
			temp_block->next = new_block;
			if(g_heap_context.tail == temp_block)
			{
				g_heap_context.tail = new_block;
			}
		}
		
		g_heap_context.total_alloc_count++;
		g_heap_context.total_alloc_size += temp_block->size;
		if(g_heap_context.total_alloc_size > g_heap_context.peak_size)
		{
			g_heap_context.peak_size = g_heap_context.total_alloc_size;
		}		
	}
	
	if(ret_addr)
	{
		print_heap_info();
	}
	else
	{
		LOGD("heap alloc failed");
	}
	
	return ret_addr;
}

void custom_free(void* ptr)
{
	PHEAP_BLOCK temp_block = NULL;
	if(ptr)
	{
		temp_block = g_heap_context.head;
		while(temp_block && (ptr != temp_block->start))
		{
			temp_block = temp_block->next;
		}
		
		if(NULL == temp_block)
		{
			g_heap_context.total_unexpected++;
			LOGD("heap address not found");
		}
		else
		{
			if(HEAP_BLOCK_ALLOCATED != temp_block->state)
			{
				g_heap_context.total_unexpected++;
			}
			
			LOGD("heap free node size %d, %s:%d", temp_block->size, temp_block->function_name, temp_block->line_num);
			temp_block->state = HEAP_BLOCK_FREE;
			memset(temp_block->function_name, 0, sizeof(temp_block->function_name));
			temp_block->line_num = 0;
			memset(temp_block->start, 0, temp_block->size);
			
			g_heap_context.total_alloc_count--;
			g_heap_context.total_alloc_size -= temp_block->size;
		}
	}
}

void print_heap_info()
{
	PHEAP_BLOCK temp_block = g_heap_context.head;
	while(NULL != temp_block)
	{
		if(HEAP_BLOCK_ALLOCATED == temp_block->state)
		{
			LOGD("heap alloc node size %d, %s:%d", temp_block->size, temp_block->function_name, temp_block->line_num);
		}
		else
		{
			LOGD("heap free node size %d", temp_block->size);
		}
		
		temp_block = temp_block->next;
	}
	
	LOGD("heap count %d, size %lld, peak %lld, fail %d, merge %d", g_heap_context.total_alloc_count, 
	g_heap_context.total_alloc_size, g_heap_context.peak_size, g_heap_context.total_unexpected, g_heap_context.total_merge_count);	
}

#endif

#if defined(USE_SYS_HEAP_TRACK)  //track the system heap usage information
//just track the function_name:line_number which requests buffer from heap
//track when it's freed
//then when know if there is any heap memory leak

#define MAX_FUNCTION_NAME_LEN        (32)

typedef struct _HEAP_BLOCK_ HEAP_BLOCK, *PHEAP_BLOCK;
typedef struct _HEAP_BLOCK_
{
	void*            start;       //system allocated buffer address
	uint32_t         size;        //request size from callers
	uint32_t         line_num;
	char             function_name[MAX_FUNCTION_NAME_LEN];   //NOTE: trunc it if too long
	PHEAP_BLOCK      next;
}HEAP_BLOCK, *PHEAP_BLOCK; 

typedef struct _HEAP_CONTEXT_
{
	uint64_t total_alloc_size;   //current allocated size from callers
	uint32_t total_alloc_count;  //increment for every request, decrement for every free
	uint32_t total_unexpected;   //tracking unexpected cases
	PHEAP_BLOCK head;
	PHEAP_BLOCK tail;	
}HEAP_CONTEXT;

static HEAP_CONTEXT g_heap_context;


void * custom_calloc(uint32_t num, uint32_t size, const char* function_name, uint32_t line_num)
{
	void* ret_addr = calloc(num * size);
	
	LOGD("heap input size %d, %s:%d", num * size, function_name, line_num);
	
	if(ret_addr)
	{
		PHEAP_BLOCK temp_block = (PHEAP_BLOCK)calloc(1, sizeof(HEAP_BLOCK));
		if(temp_block)
		{
			temp_block->start = ret_addr;
			temp_block->size = num * size;
			temp_block->line_num = line_num;
			strncpy(temp_block->function_name, func_name, sizeof(temp_block->function_name));
			
			g_heap_context.total_alloc_count++;
			g_heap_context.total_alloc_size += temp_block->size;
			
			if(NULL == g_heap_context.head)
			{
				g_heap_context.head = temp_block;
				g_heap_context.tail = temp_block;
			}
			else
			{
				g_heap_context.tail->next = temp_block;
				g_heap_context.tail = temp_block;
			}
		}
		else
		{
			g_heap_context.total_unexpected++;
		}
	}
	else
	{
		g_heap_context.total_unexpected++;
	}
	
	
	if(ret_addr)
	{
		print_heap_info();
	}
	else
	{
		LOGD("heap alloc failed");
	}
	
	return ret_addr;
}

void custom_free(void* ptr)
{
	PHEAP_BLOCK temp_block = NULL;
	PHEAP_BLOCK previous_block = NULL;
	if(ptr)
	{
		temp_block = g_heap_context.head;
		previous_block = NULL;
		while(temp_block && (ptr != temp_block->start))
		{
			previous_block = temp_block;
			temp_block = temp_block->next;
		}
		
		if(NULL == temp_block)
		{
			g_heap_context.total_unexpected++;
			LOGD("heap address not found");
		}
		else
		{			
			LOGD("heap free node size %d, %s:%d", temp_block->size, temp_block->function_name, temp_block->line_num);
			if(g_heap_context.head != temp_block && g_heap_context.tail != temp_block )
			{
				previous_block->next = temp_block->next;
			}
			else  //found block could be head or tail or head and tail(only 1 block)
			{		  
				if(g_heap_context.head == temp_block)
				{
					g_heap_context.head = temp_block->next;				
				}
				
				if(g_heap_context.tail == temp_block)
				{
					g_heap_context.tail = previous_block;
					if(NULL != previous_block)
					{
						previous_block->next = NULL;
					}
				}
			}
			free(temp_block);
			
			g_heap_context.total_alloc_count--;
			g_heap_context.total_alloc_size -= temp_block->size;
		}
		
		free(ptr);
	}
}

void print_heap_info()
{
	PHEAP_BLOCK temp_block = g_heap_context.head;
	while(NULL != temp_block)
	{
		LOGD("heap alloc node size %d, %s:%d", temp_block->size, temp_block->function_name, temp_block->line_num);
		
		temp_block = temp_block->next;
	}
	
	LOGD("heap count %d, size %lld, fail %d", g_heap_context.total_alloc_count, g_heap_context.total_alloc_size, g_heap_context.total_unexpected);	
}
#endif

调试过程中的问题总结：
1. 使用自定义堆，会直接增大编译生成的二进制文件大小；可以减少编译脚本（链接文件）中的HEAP_SIZE，有时可能要权衡一下。问题来了，这个HEAP_SZIE可以减少到0吗？ 肯定是不行的，虽然我们代码不用缺省堆，但调用我们代码的，和我们代码调用的，对我们来说都是黑盒子，能保证他们都不用缺省堆吗？保险起见，可以先使用缺省值吧。
2. 那么这个全局区域最大设为多少呢？ 可以根据peak_size统计进行设置，甚至也可以实现方案略加修改，变为自定义堆+缺省堆的方案。
3. 低级错误1：日志打印的%s和%d与实际的参数不对应导致的问题。由此可见，本地搭建完整的测试环境的重要性。
4. 低级错误2：最初内存分配custom_calloc的入参num/size为uint16_t，程序实际使用过程中会溢出。由此可见，测试驱动开发，测试用例设计的重要性。
5. 低级错误3：custom_calloc中最初实现的查找“第一个未分配且buff足够大的HEAP_BLOCK”的while循环的条件没有指定正确。这类条件设定，逻辑一定要越简单越清晰越好。

那最终问题解决了吗？ 解决了，不是内存泄漏，不是一个问题。
 

【2022年5.1节 重庆】

Thomas_TangShiMing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
css div自定义属性,CSS 自定义属性 - 入门
weixin_39595487的博客
08-04 1227
引言CSS语言是一种声明式语言，不像其他语言有变量、条件和逻辑等特性，因为这个原因，社区中有了各种CSS处理器语言，比如Sass、LESS和Stylus等。这些处理器语言引入了一些类似其他程序语言的特性，比如变量、运算符和逻辑运算等。虽然CSS处理器给编写和维护CSS带来了一些便利，但是需要额外的编译，所以社区开始将CSS处理器中的变量引入到原生CSS中，最后形成了今天的CSS自定义属性。一、CS...
GBase 8a 支持存储过程、自定义函数的定义和使用
weixin_62941622的博客
11-30 3157
GBase 8a 支持存储过程、自定义函数的定义和使用
使用CSS自定义属性实现页面的主题切换
jimojianghu的专栏
04-29 2622
CSS自定义属性(Custom Properties)，在一个css选择器内部进行定义，使用两个短横连接线 `--` 作为开头命名的名称即被称为自定义属性。
CSS中的自定义变量使用，var()语法
houzhyan-博客
08-24 2413
惯例先看代码： :root{ --white-max: #fff;  --white-bright: #f5f5f5;  --white-light: #eee;  --white-dark: #ddd;  } .navbar ul&gt;li&gt;a{ color: var(--white-max); font-size: 1.1em; font-weight: bold; } .pan...
css自定义属性和H5自定义属性
SSophia的博客
08-30 957
 复杂的网站都会有大量的css代码，通常也会有很多重复的值。举个例子，同样的一个颜色可能在成百上千的地方被使用到，如果这个值发生了变化，需要全局搜索并且一个一个去替换，效率不高且容易出错。..................
android使用属性动画代替补间动画
江南一点雨的专栏
10-17 3378
本文参考Android属性动画完全解析(上)，初识属性动画的基本用法 android3.0之前一共有两种动画，分别是frame动画和tween动画，关于这两种动画如果不了解可以查看我之前的文章android之frame动画详解 和android之tween动画详解 ，frame动画就是逐帧动画，把多张图片放在一起连续播放实现一种类似于gif图片的动画效果，tween动画就是补间动画，主要是对图像进行
Linux系统日志 - logrotate与syslog
生活需要深度
08-12 6632
syslogd专门记录非内核的其他设备所产生的日志，当系统的控制权由系统交给init的时候，日志信息的记录由syslogd负责记录。Logrotate是一个日志文件管理工具，用来把旧的日志文件删除，并创建新的日志文件，即日志的转储。syslog工具由一个守护程序组成，接受访问系统的日志信息并且根据/etc/syslog.conf配置文件中的指令处理日志信息。指向信息的指针，一般为程序名，ident所表示的字符串将固定地加在每行日志的前面以标识这个日志，通常就写成当前程序的名称以作标记。.........
自定义比较函数用 函数对象或lamda表达式 代替比较函数
qfturauyls的博客
11-09 1066
【1】 说明：在使用stl库中的查找和排序时，往往会使用自定义比较函数。使用函数对象的方式比传输函数指针的方式具有更好的性能。lamba表达式的行为类似于带有()运算符的函数对象，性能均优于比较函数。 引申——斯特潘诺夫的抽象惩罚：C++标准库提供的直接可用的算法和数据结构，能适用于很多情况，但即使是最优秀的标准库算法，往往无法与最佳的手工编写算法匹敌。即为斯特潘诺夫的抽象惩罚。 ...
操作系统—进程控制实验
weixin_45728192的博客
03-28 9733
文章目录1.关于实验前环境准备2.关于可能用到的命令3.关于makefile4.关于实验说明5.关于实验指导的程序6.关于独立实验Q(跪求大佬解答)？ 1.关于实验前环境准备 要准备好C语言的编译环境，安装方法为sudo apt-get install gcc 相信大家编译环境都已经准备好了，这里因为已经安装好了，就不重复安装了，有问题百度上面也有详细的解决方案~ 2.关于可能用到的命令 sudo 表示 “superuser do”，它允许已验证的用户以其他用户的身份来运行命令。 用法： sudo
操作系统实验一
weixin_43979090的博客
05-20 4599
广州大学学生实验报告 开课学院：计算机科学与网络工程学院 实验室：计算机软件实验室 2020 年5月20 日 学院 计算机科学与教育软件学院 年级/专业/班 计科183 姓名 张健介 学号 1806100162 实验课程名称 操作系统实验 成绩 实验项目名称 进程管理与进程通信 指导老师 张艳玲 实验一 进程管理与进程通信 一、实验目的 1、掌握进程的概念，明确进程的含义。 2、认识并了解进程并发执行的实质，进程的阻塞与唤醒，终止与退出的过程。
史上超级详细的Oracle_SQLPlus命令使用大全
03-03
Oracle SQL*PLUS是Oracle数据库系统中的一个强大的交互式查询和数据管理工具，它允许用户直接与数据库进行交互，执行SQL语句，管理数据库对象，并进行数据的查询、更新和分析。下面将详细介绍其中的一些关键命令。 ...
数据结构——顺序表
脑壳有点痒，好像要长脑子了！
08-03 969
顺序表是数据结构中的一种重要形式，它属于线性表的一种顺序存储结构，其逻辑上相邻的元素在物理存储位置上也相邻。用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。
数据结构（邓俊辉）学习笔记】词典 03—— 排解冲突(1)
最新发布
weixin_44399845的博客
08-06 491
学习下词条的排解冲突方法
数据结构 二叉树和堆总结
gma999的博客
07-31 1088
二叉树和堆的总结
【数据结构】堆的实现
t5y22的博客
08-03 600
堆
GNU Make 3.79 使用指南：Makefile详解与规则编写
"GNU Make 使用手册" 《GNU Make 使用手册》是关于如何编写和使用Makefile文件的详尽指南，适用于那些希望通过GNU Make自动化构建过程的开发者。手册涵盖了从基础到高级的各种主题，包括Makefile的基本结构、规则的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值