当前位置：首页 > news >正文

内存管理原理与策略

news 2026/5/22 0:14:21

内存管理原理与策略

1. 技术分析

1.1 内存管理概述

内存管理是操作系统的核心功能：

内存管理目标 高效利用: 最大化内存利用率 保护隔离: 进程间隔离 虚拟地址: 提供统一地址空间 管理策略: 分区管理 分页管理 分段管理 段页式管理

1.2 虚拟内存

虚拟内存特点 地址空间: 连续虚拟地址 按需加载: 只加载需要的页面 内存保护: 页表权限控制 核心技术: 分页机制 页表 TLB缓存

1.3 内存分配策略

策略	特点	适用场景
首次适应	找第一个足够大的块	通用
最佳适应	找最小足够大的块	碎片少
最差适应	找最大的块	大块分配

2. 核心功能实现

2.1 分页机制

#include <stdio.h> #include <stdlib.h> #include <stdint.h> #define PAGE_SIZE 4096 #define NUM_PAGES 1024 // 模拟页表 uint32_t page_table[NUM_PAGES]; uint8_t physical_memory[NUM_PAGES * PAGE_SIZE]; void init_page_table() { for (int i = 0; i < NUM_PAGES; i++) { page_table[i] = i; // 简单映射 } } uint8_t* translate_address(uint32_t virtual_addr) { uint32_t page_num = virtual_addr / PAGE_SIZE; uint32_t offset = virtual_addr % PAGE_SIZE; if (page_num >= NUM_PAGES) { printf("地址越界\n"); return NULL; } uint32_t physical_page = page_table[page_num]; return &physical_memory[physical_page * PAGE_SIZE + offset]; } void write_memory(uint32_t addr, uint8_t value) { uint8_t* ptr = translate_address(addr); if (ptr) { *ptr = value; } } uint8_t read_memory(uint32_t addr) { uint8_t* ptr = translate_address(addr); return ptr ? *ptr : 0; }

2.2 内存分配器

#include <stdio.h> #include <stdlib.h> #include <string.h> #define HEAP_SIZE 1024 * 1024 typedef struct Block { size_t size; struct Block *next; int free; } Block; Block *heap_start; void init_heap() { heap_start = (Block *)malloc(HEAP_SIZE); heap_start->size = HEAP_SIZE - sizeof(Block); heap_start->next = NULL; heap_start->free = 1; } void* my_malloc(size_t size) { Block *current = heap_start; while (current) { if (current->free && current->size >= size) { // 分割块 if (current->size > size + sizeof(Block)) { Block *new_block = (Block *)((char *)current + sizeof(Block) + size); new_block->size = current->size - size - sizeof(Block); new_block->next = current->next; new_block->free = 1; current->size = size; current->next = new_block; } current->free = 0; return (char *)current + sizeof(Block); } current = current->next; } return NULL; } void my_free(void *ptr) { if (!ptr) return; Block *block = (Block *)((char *)ptr - sizeof(Block)); block->free = 1; // 合并相邻空闲块 Block *current = heap_start; while (current && current->next) { if (current->free && current->next->free) { current->size += sizeof(Block) + current->next->size; current->next = current->next->next; } else { current = current->next; } } }

2.3 页面置换算法

#include <stdio.h> #include <stdlib.h> #define NUM_FRAMES 3 #define NUM_PAGES 10 // FIFO页面置换 int fifo_page_replacement(int *pages, int n) { int frames[NUM_FRAMES]; int page_faults = 0; int next_frame = 0; for (int i = 0; i < NUM_FRAMES; i++) { frames[i] = -1; } for (int i = 0; i < n; i++) { int page = pages[i]; int found = 0; for (int j = 0; j < NUM_FRAMES; j++) { if (frames[j] == page) { found = 1; break; } } if (!found) { frames[next_frame] = page; next_frame = (next_frame + 1) % NUM_FRAMES; page_faults++; } } return page_faults; } // LRU页面置换 int lru_page_replacement(int *pages, int n) { int frames[NUM_FRAMES]; int last_used[NUM_FRAMES]; int page_faults = 0; int time = 0; for (int i = 0; i < NUM_FRAMES; i++) { frames[i] = -1; last_used[i] = 0; } for (int i = 0; i < n; i++) { int page = pages[i]; int found = 0; int lru_index = 0; for (int j = 0; j < NUM_FRAMES; j++) { if (frames[j] == page) { found = 1; last_used[j] = time++; break; } if (last_used[j] < last_used[lru_index]) { lru_index = j; } } if (!found) { frames[lru_index] = page; last_used[lru_index] = time++; page_faults++; } } return page_faults; }

3. 性能对比

3.1 页面置换算法对比

算法	页面错误率	复杂度	实现难度
FIFO	中	O(1)	低
LRU	低	O(n)	中
OPT	最低	O(n²)	高

3.2 内存分配器对比

分配器	碎片率	分配速度	适用场景
首次适应	中	快	通用
最佳适应	低	慢	小对象
伙伴系统	低	快	大对象

3.3 内存映射对比

方式	灵活性	性能	适用场景
分页	高	中	通用
分段	中	高	代码/数据分离
段页式	高	中	现代系统

4. 最佳实践

4.1 内存优化

// 使用内存池减少分配开销 class MemoryPool { private: void **pool; int size; int top; public: MemoryPool(int n, size_t item_size) { size = n; top = 0; pool = (void **)malloc(n * sizeof(void *)); for (int i = 0; i < n; i++) { pool[i] = malloc(item_size); } } ~MemoryPool() { for (int i = 0; i < top; i++) { free(pool[i]); } free(pool); } void* allocate() { if (top < size) { return pool[top++]; } return NULL; } void deallocate(void *ptr) { if (top > 0) { pool[--top] = ptr; } } };

4.2 内存检测

// 简单的内存泄漏检测 #define DEBUG_MALLOC #ifdef DEBUG_MALLOC #include <stdio.h> static int alloc_count = 0; void* debug_malloc(size_t size, const char *file, int line) { void *ptr = malloc(size); alloc_count++; printf("Malloc %p (%zu bytes) at %s:%d\n", ptr, size, file, line); return ptr; } void debug_free(void *ptr, const char *file, int line) { free(ptr); alloc_count--; printf("Free %p at %s:%d\n", ptr, file, line); } #define malloc(s) debug_malloc(s, __FILE__, __LINE__) #define free(p) debug_free(p, __FILE__, __LINE__) #endif