munlock系统调用及示例
munlock 和 munlockall 函数详解
链接到标题
1. 函数介绍
链接到标题
munlock 和 munlockall 是 Linux 系统中用于解锁内存页面的系统调用，它们是 mlock 和 mlockall 的对应函数。可以把它们想象成"内存保护盾的解除器"——mlock/mlockall 给内存加上保护盾防止被交换，而 munlock/munlockall 则是移除这些保护盾。
在实时系统或对性能要求极高的应用中，内存锁定可以确保关键数据始终驻留在物理内存中。但当不再需要这种保护时，应该使用 munlock 和 munlockall 来释放资源，让系统可以正常管理内存。
2. 函数原型
链接到标题
#include
int munlock(const void *addr, size_t len);
int munlockall(void);
3. 功能
链接到标题
munlock: 解锁指定内存区域的页面，允许它们被交换到磁盘
munlockall: 解锁进程的所有内存页面，允许所有页面被交换
4. 参数
链接到标题
munlock 参数
链接到标题
addr: 要解锁的内存区域起始地址
len: 要解锁的内存区域长度（以字节为单位）
munlockall 参数
链接到标题
无参数，解锁进程的所有内存页面
5. 返回值
链接到标题
成功: 返回 0
失败: 返回 -1，并设置相应的 errno 错误码
6. 常见错误码
链接到标题
EPERM: 权限不足
EINVAL: 参数无效（地址未对齐或长度为0）
ENOMEM: 地址范围无效
ENOSYS: 系统不支持内存锁定
7. 相关函数
链接到标题
mlock: 锁定指定内存区域
mlockall: 锁定所有内存页面
mlock2: 带扩展选项的内存锁定（Linux 4.4+）
getrlimit/setrlimit: 获取/设置资源限制
8. 示例代码
链接到标题
示例1：基础用法 - 内存锁定与解锁
链接到标题
#define _GNU_SOURCE
#include
#include
#include
#include
#include
#include
#include
// 显示内存锁定限制
void show_memory_lock_limits() {
struct rlimit limit;
printf("=== 内存锁定限制 ===\n");
if (getrlimit(RLIMIT_MEMLOCK, &limit) == 0) {
printf("最大可锁定内存:\n");
if (limit.rlim_cur == RLIM_INFINITY) {
printf(" 软限制: 无限制\n");
} else {
printf(" 软限制: %lu 字节 (%.2f MB)\n",
(unsigned long)limit.rlim_cur,
(double)limit.rlim_cur / (1024 * 1024));
}
if (limit.rlim_max == RLIM_INFINITY) {
printf(" 硬限制: 无限制\n");
} else {
printf(" 硬限制: %lu 字节 (%.2f MB)\n",
(unsigned long)limit.rlim_max,
(double)limit.rlim_max / (1024 * 1024));
}
}
printf("当前用户 UID: %d\n", getuid());
printf("\n");
}
// 分配并锁定内存
void* allocate_and_lock_memory(size_t size_mb) {
size_t size_bytes = size_mb * 1024 * 1024;
// 分配内存
void *buffer = malloc(size_bytes);
if (!buffer) {
perror("内存分配失败");
return NULL;
}
printf("分配内存: %zu MB (%p)\n", size_mb, buffer);
// 初始化内存
printf("初始化内存...\n");
memset(buffer, 0xAA, size_bytes);
// 尝试锁定内存
printf("尝试锁定内存...\n");
if (mlock(buffer, size_bytes) == 0) {
printf("✓ 内存锁定成功\n");
} else {
if (errno == EPERM) {
printf("⚠ 权限不足: 需要 root 权限或 CAP_IPC_LOCK 能力\n");
} else {
printf("✗ 内存锁定失败: %s\n", strerror(errno));
}
}
return buffer;
}
int main() {
printf("=== munlock 基础示例 ===\n\n");
// 显示系统信息
show_memory_lock_limits();
// 1. 分配并锁定内存
printf("1. 分配并锁定内存:\n");
void *memory_block = allocate_and_lock_memory(10); // 10MB
if (!memory_block) {
return 1;
}
// 2. 使用锁定的内存
printf("\n2. 使用锁定的内存:\n");
for (size_t i = 0; i < 10 * 1024 * 1024; i += 4096) {
((char*)memory_block)[i] = (char)(i % 256);
}
printf("✓ 内存使用完成\n");
// 3. 解锁部分内存
printf("\n3. 解锁部分内存 (前 5MB):\n");
size_t unlock_size = 5 * 1024 * 1024;
if (munlock(memory_block, unlock_size) == 0) {
printf("✓ 成功解锁前 %zu MB 内存\n", unlock_size / (1024 * 1024));
} else {
printf("✗ 解锁失败: %s\n", strerror(errno));
}
// 4. 解锁剩余内存
printf("\n4. 解锁剩余内存:\n");
void *remaining_addr = (char*)memory_block + unlock_size;
size_t remaining_size = 10 * 1024 * 1024 - unlock_size;
if (munlock(remaining_addr, remaining_size) == 0) {
printf("✓ 成功解锁剩余 %zu MB 内存\n", remaining_size / (1024 * 1024));
} else {
printf("✗ 解锁失败: %s\n", strerror(errno));
}
// 5. 重新锁定并使用 munlockall
printf("\n5. 重新锁定并使用 munlockall:\n");
if (mlock(memory_block, 10 * 1024 * 1024) == 0) {
printf("✓ 重新锁定内存成功\n");
// 使用 munlockall 解锁所有内存
if (munlockall() == 0) {
printf("✓ munlockall 成功解锁所有内存\n");
} else {
printf("✗ munlockall 失败: %s\n", strerror(errno));
}
}
// 6. 清理资源
printf("\n6. 清理资源:\n");
free(memory_block);
printf("✓ 内存已释放\n");
printf("\n=== 说明 ===\n");
printf("1. munlock: 解锁指定内存区域\n");
printf("2. munlockall: 解锁所有内存页面\n");
printf("3. 解锁后的内存可以被交换到磁盘\n");
printf("4. 解锁操作不需要特殊权限\n");
printf("5. 应该在不需要内存锁定时及时解锁\n");
return 0;
}
示例2：内存锁定管理器
链接到标题
#define _GNU_SOURCE
#include
#include
#include
#include
#include
#include
#include
#include
#include
// 内存块结构体
struct memory_block {
void *addr;
size_t size;
int is_locked;
char name[64];
};
// 全局内存块数组
#define MAX_BLOCKS 10
struct memory_block memory_blocks[MAX_BLOCKS];
int block_count = 0;
pthread_mutex_t blocks_mutex = PTHREAD_MUTEX_INITIALIZER;
// 信号处理标志
volatile sig_atomic_t running = 1;
// 信号处理函数
void signal_handler(int sig) {
printf("\n收到信号 %d，准备退出...\n", sig);
running = 0;
}
// 设置信号处理
void setup_signal_handlers() {
struct sigaction sa;
sa.sa_handler = signal_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGINT, &sa, NULL); // Ctrl+C
sigaction(SIGTERM, &sa, NULL); // 终止信号
}
// 创建并锁定内存块
int create_locked_memory_block(const char *name, size_t size_mb) {
pthread_mutex_lock(&blocks_mutex);
if (block_count >= MAX_BLOCKS) {
pthread_mutex_unlock(&blocks_mutex);
fprintf(stderr, "内存块数量已达上限\n");
return -1;
}
size_t size_bytes = size_mb * 1024 * 1024;
void *buffer = malloc(size_bytes);
if (!buffer) {
pthread_mutex_unlock(&blocks_mutex);
perror("内存分配失败");
return -1;
}
// 初始化内存
memset(buffer, 0, size_bytes);
// 尝试锁定内存
int lock_result = mlock(buffer, size_bytes);
// 记录内存块信息
struct memory_block *block = &memory_blocks[block_count];
block->addr = buffer;
block->size = size_bytes;
block->is_locked = (lock_result == 0);
strncpy(block->name, name, sizeof(block->name) - 1);
block->name[sizeof(block->name) - 1] = '\0';
block_count++;
pthread_mutex_unlock(&blocks_mutex);
printf("创建内存块: %s (%zu MB) - %s\n",
name, size_mb, lock_result == 0 ? "已锁定" : "锁定失败");
return block_count - 1;
}
// 解锁指定内存块
int unlock_memory_block(int index) {
pthread_mutex_lock(&blocks_mutex);
if (index < 0 || index >= block_count) {
pthread_mutex_unlock(&blocks_mutex);
fprintf(stderr, "无效的内存块索引: %d\n", index);
return -1;
}
struct memory_block *block = &memory_blocks[index];
if (block->is_locked) {
if (munlock(block->addr, block->size) == 0) {
block->is_locked = 0;
printf("解锁内存块: %s (%.2f MB)\n",
block->name, (double)block->size / (1024 * 1024));
pthread_mutex_unlock(&blocks_mutex);
return 0;
} else {
printf("解锁失败: %s - %s\n", block->name, strerror(errno));
pthread_mutex_unlock(&blocks_mutex);
return -1;
}
} else {
printf("内存块 %s 未被锁定\n", block->name);
pthread_mutex_unlock(&blocks_mutex);
return 0;
}
}
// 解锁所有内存块
void unlock_all_memory_blocks() {
pthread_mutex_lock(&blocks_mutex);
printf("解锁所有内存块:\n");
for (int i = 0; i < block_count; i++) {
struct memory_block *block = &memory_blocks[i];
if (block->is_locked) {
if (munlock(block->addr, block->size) == 0) {
block->is_locked = 0;
printf(" ✓ %s (%.2f MB)\n",
block->name, (double)block->size / (1024 * 1024));
} else {
printf(" ✗ %s - %s\n", block->name, strerror(errno));
}
} else {
printf(" ○ %s (未锁定)\n", block->name);
}
}
pthread_mutex_unlock(&blocks_mutex);
}
// 显示内存块状态
void show_memory_blocks_status() {
pthread_mutex_lock(&blocks_mutex);
printf("=== 内存块状态 ===\n");
if (block_count == 0) {
printf("没有内存块\n");
} else {
for (int i = 0; i < block_count; i++) {
struct memory_block *block = &memory_blocks[i];
printf("块 %d: %s\n", i, block->name);
printf(" 地址: %p\n", block->addr);
printf(" 大小: %.2f MB\n", (double)block->size / (1024 * 1024));
printf(" 状态: %s\n", block->is_locked ? "已锁定" : "未锁定");
printf("\n");
}
}
pthread_mutex_unlock(&blocks_mutex);
}
// 清理所有内存块
void cleanup_all_memory_blocks() {
pthread_mutex_lock(&blocks_mutex);
printf("清理所有内存块:\n");
for (int i = 0; i < block_count; i++) {
struct memory_block *block = &memory_blocks[i];
// 如果仍被锁定，先解锁
if (block->is_locked) {
if (munlock(block->addr, block->size) == 0) {
printf(" ✓ 解锁 %s\n", block->name);
} else {
printf(" ✗ 解锁 %s 失败: %s\n", block->name, strerror(errno));
}
}
// 释放内存
free(block->addr);
printf(" ✓ 释放 %s\n", block->name);
}
block_count = 0;
pthread_mutex_unlock(&blocks_mutex);
}
// 模拟内存使用的工作线程
void* worker_thread(void* arg) {
int block_index = *(int*)arg;
pthread_mutex_lock(&blocks_mutex);
if (block_index >= 0 && block_index < block_count) {
struct memory_block *block = &memory_blocks[block_index];
printf("工作线程开始使用内存块: %s\n", block->name);
pthread_mutex_unlock(&blocks_mutex);
// 在内存块中进行一些操作
char *buffer = (char*)block->addr;
size_t chunk_size = block->size / 100;
for (int i = 0; running && i < 100; i++) {
// 写入数据
for (size_t j = 0; j < chunk_size && (i * chunk_size + j) < block->size; j++) {
buffer[i * chunk_size + j] = (char)((i + j) % 256);
}
// 读取数据
volatile long sum = 0;
for (size_t j = 0; j < chunk_size && (i * chunk_size + j) < block->size; j++) {
sum += buffer[i * chunk_size + j];
}
if (i % 20 == 0) {
printf("线程处理进度: %d%%\n", i);
}
usleep(50000); // 50ms
}
printf("工作线程完成: %s\n", block->name);
} else {
pthread_mutex_unlock(&blocks_mutex);
printf("无效的内存块索引: %d\n", block_index);
}
return NULL;
}
int main() {
pthread_t threads[3];
int thread_indices[3];
printf("=== 内存锁定管理器示例 ===\n\n");
// 设置信号处理
setup_signal_handlers();
// 显示初始状态
printf("创建测试内存块:\n");
// 创建多个内存块
create_locked_memory_block("Critical_Data", 5); // 5MB 关键数据
create_locked_memory_block("Cache_Buffer", 10); // 10MB 缓存
create_locked_memory_block("Temp_Work", 2); // 2MB 临时工作区
show_memory_blocks_status();
// 创建工作线程
printf("创建工作线程...\n");
for (int i = 0; i < 3; i++) {
thread_indices[i] = i;
if (pthread_create(&threads[i], NULL, worker_thread, &thread_indices[i]) != 0) {
perror("创建线程失败");
continue;
}
}
// 运行一段时间后解锁部分内存
printf("运行中... (按 Ctrl+C 退出)\n");
sleep(2);
printf("\n=== 动态内存管理 ===\n");
// 解锁临时工作区
printf("解锁临时工作区:\n");
unlock_memory_block(2); // Temp_Work
show_memory_blocks_status();
sleep(2);
// 再次解锁缓存区
printf("解锁缓存区:\n");
unlock_memory_block(1); // Cache_Buffer
show_memory_blocks_status();
// 等待用户中断或线程完成
for (int i = 0; i < 3; i++) {
pthread_join(threads[i], NULL);
}
// 最终清理
printf("\n=== 最终清理 ===\n");
unlock_all_memory_blocks();
show_memory_blocks_status();
cleanup_all_memory_blocks();
printf("\n=== 内存锁定管理说明 ===\n");
printf("最佳实践:\n");
printf("1. 只锁定真正需要的内存区域\n");
printf("2. 及时解锁不需要的锁定内存\n");
printf("3. 避免过度使用内存锁定\n");
printf("4. 监控内存锁定资源使用情况\n");
printf("5. 在程序退出时清理所有锁定\n");
printf("\n");
printf("munlock 优势:\n");
printf("1. 精确控制: 可以解锁特定内存区域\n");
printf("2. 资源管理: 允许系统回收内存资源\n");
printf("3. 灵活性: 可以部分解锁内存\n");
printf("4. 无权限要求: 解锁操作不需要特殊权限\n");
return 0;
}
示例3：完整的内存锁定监控工具
链接到标题
#define _GNU_SOURCE
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
// 配置结构体
struct unlock_config {
int unlock_all; // 解锁所有内存
int show_status; // 显示状态
int verbose; // 详细输出
char **addresses; // 要解锁的地址列表
size_t *sizes; // 对应的大小列表
int addr_count; // 地址数量
int test_mode; // 测试模式
size_t test_size; // 测试内存大小
};
// 显示系统内存信息
void show_system_memory_info() {
printf("=== 系统内存信息 ===\n");
FILE *meminfo = fopen("/proc/meminfo", "r");
if (meminfo) {
char line[256];
int count = 0;
while (fgets(line, sizeof(line), meminfo) && count < 8) {
if (strncmp(line, "MemTotal:", 9) == 0 ||
strncmp(line, "MemFree:", 8) == 0 ||
strncmp(line, "MemAvailable:", 13) == 0 ||
strncmp(line, "SwapTotal:", 10) == 0 ||
strncmp(line, "SwapFree:", 9) == 0 ||
strncmp(line, "Cached:", 7) == 0 ||
strncmp(line, "Buffers:", 8) == 0 ||
strncmp(line, "Active:", 7) == 0) {
printf("%s", line);
count++;
}
}
fclose(meminfo);
}
printf("\n");
}
// 显示内存锁定限制
void show_lock_limits() {
struct rlimit limit;
printf("=== 内存锁定限制 ===\n");
if (getrlimit(RLIMIT_MEMLOCK, &limit) == 0) {
printf("最大可锁定内存:\n");
if (limit.rlim_cur == RLIM_INFINITY) {
printf(" 软限制: 无限制\n");
} else {
printf(" 软限制: %lu 字节 (%.2f MB)\n",
(unsigned long)limit.rlim_cur,
(double)limit.rlim_cur / (1024 * 1024));
}
if (limit.rlim_max == RLIM_INFINITY) {
printf(" 硬限制: 无限制\n");
} else {
printf(" 硬限制: %lu 字节 (%.2f MB)\n",
(unsigned long)limit.rlim_max,
(double)limit.rlim_max / (1024 * 1024));
}
}
printf("\n");
}
// 解析地址字符串
void* parse_address(const char *addr_str) {
char *endptr;
unsigned long addr = strtoul(addr_str, &endptr, 16);
if (*endptr != '\0') {
fprintf(stderr, "无效的地址格式: %s\n", addr_str);
return NULL;
}
return (void*)addr;
}
// 解析大小字符串
size_t parse_size(const char *size_str) {
char *endptr;
unsigned long size = strtoul(size_str, &endptr, 10);
if (*endptr == 'G' || *endptr == 'g') {
size *= 1024 * 1024 * 1024;
} else if (*endptr == 'M' || *endptr == 'm') {
size *= 1024 * 1024;
} else if (*endptr == 'K' || *endptr == 'k') {
size *= 1024;
}
return (size_t)size;
}
// 执行 munlock 操作
int perform_munlock(void *addr, size_t size, const char *description) {
if (description) {
printf("解锁内存区域: %s\n", description);
printf(" 地址: %p\n", addr);
printf(" 大小: %zu 字节 (%.2f MB)\n", size, (double)size / (1024 * 1024));
}
if (munlock(addr, size) == 0) {
printf("✓ 解锁成功\n");
return 0;
} else {
printf("✗ 解锁失败: %s\n", strerror(errno));
return -1;
}
}
// 执行 munlockall 操作
int perform_munlockall() {
printf("解锁所有内存页面...\n");
if (munlockall() == 0) {
printf("✓ 成功解锁所有内存页面\n");
return 0;
} else {
printf("✗ 解锁所有内存页面失败: %s\n", strerror(errno));
return -1;
}
}
// 测试模式：分配、锁定、然后解锁内存
int test_mode_operation(size_t size_mb) {
size_t size_bytes = size_mb * 1024 * 1024;
printf("=== 测试模式 ===\n");
printf("分配测试内存: %zu MB\n", size_mb);
// 分配内存
void *buffer = malloc(size_bytes);
if (!buffer) {
perror("内存分配失败");
return -1;
}
// 初始化内存
printf("初始化内存...\n");
memset(buffer, 0xAA, size_bytes);
// 锁定内存
printf("锁定内存...\n");
if (mlock(buffer, size_bytes) == 0) {
printf("✓ 内存锁定成功\n");
} else {
printf("✗ 内存锁定失败: %s\n", strerror(errno));
free(buffer);
return -1;
}
// 使用内存
printf("使用锁定的内存...\n");
for (size_t i = 0; i < size_bytes; i += 4096) {
((char*)buffer)[i] = (char)(i % 256);
}
// 解锁内存
printf("解锁内存...\n");
if (munlock(buffer, size_bytes) == 0) {
printf("✓ 内存解锁成功\n");
} else {
printf("✗ 内存解锁失败: %s\n", strerror(errno));
}
// 释放内存
free(buffer);
printf("✓ 内存已释放\n");
return 0;
}
// 显示帮助信息
void show_help(const char *program_name) {
printf("用法: %s [选项]\n", program_name);
printf("\n选项:\n");
printf(" -a, --all 解锁所有内存页面\n");
printf(" -s, --status 显示系统内存状态\n");
printf(" -l, --limits 显示内存锁定限制\n");
printf(" -u, --unlock=ADDR:SIZE 解锁指定内存区域\n");
printf(" -t, --test[=SIZE] 测试模式 (默认 10MB)\n");
printf(" -v, --verbose 详细输出\n");
printf(" -h, --help 显示此帮助信息\n");
printf("\n地址格式:\n");
printf(" 地址: 十六进制格式 (如 0x7fff12345678)\n");
printf(" 大小: 数字加单位 (如 1024, 1K, 1M, 1G)\n");
printf("\n示例:\n");
printf(" %s -a # 解锁所有内存\n", program_name);
printf(" %s -u 0x7fff12345678:1M # 解锁指定区域\n", program_name);
printf(" %s -s -l # 显示状态和限制\n", program_name);
printf(" %s -t 50 # 测试 50MB 内存\n", program_name);
printf(" %s --unlock=0x12345678:4K --verbose # 详细模式\n", program_name);
}
int main(int argc, char *argv[]) {
struct unlock_config config = {
.unlock_all = 0,
.show_status = 0,
.verbose = 0,
.addresses = NULL,
.sizes = NULL,
.addr_count = 0,
.test_mode = 0,
.test_size = 10 // 默认 10MB
};
printf("=== 内存解锁工具 ===\n\n");
// 解析命令行参数
static struct option long_options[] = {
{"all", no_argument, 0, 'a'},
{"status", no_argument, 0, 's'},
{"limits", no_argument, 0, 'l'},
{"unlock", required_argument, 0, 'u'},
{"test", optional_argument, 0, 't'},
{"verbose", no_argument, 0, 'v'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
int opt;
while ((opt = getopt_long(argc, argv, "aslu:t::vh", long_options, NULL)) != -1) {
switch (opt) {
case 'a':
config.unlock_all = 1;
break;
case 's':
config.show_status = 1;
break;
case 'l':
show_lock_limits();
return 0;
case 'u': {
// 解析 ADDR:SIZE 格式
char *colon = strchr(optarg, ':');
if (colon) {
*colon = '\0';
void *addr = parse_address(optarg);
size_t size = parse_size(colon + 1);
if (addr && size > 0) {
config.addresses = realloc(config.addresses,
(config.addr_count + 1) * sizeof(void*));
config.sizes = realloc(config.sizes,
(config.addr_count + 1) * sizeof(size_t));
config.addresses[config.addr_count] = addr;
config.sizes[config.addr_count] = size;
config.addr_count++;
if (config.verbose) {
printf("添加解锁区域: %p - %zu 字节\n", addr, size);
}
} else {
fprintf(stderr, "无效的地址或大小: %s\n", optarg);
return 1;
}
} else {
fprintf(stderr, "地址格式应为 ADDR:SIZE\n");
return 1;
}
break;
}
case 't':
config.test_mode = 1;
if (optarg) {
config.test_size = strtoul(optarg, NULL, 10);
}
break;
case 'v':
config.verbose = 1;
break;
case 'h':
show_help(argv[0]);
return 0;
default:
fprintf(stderr, "使用 '%s --help' 查看帮助信息\n", argv[0]);
return 1;
}
}
// 显示系统信息
if (config.verbose || config.show_status) {
show_system_memory_info();
show_lock_limits();
}
// 测试模式
if (config.test_mode) {
if (test_mode_operation(config.test_size) != 0) {
return 1;
}
if (!config.unlock_all && config.addr_count == 0) {
return 0;
}
}
// 执行解锁操作
int result = 0;
if (config.unlock_all) {
result = perform_munlockall();
} else if (config.addr_count > 0) {
for (int i = 0; i < config.addr_count; i++) {
char description[128];
snprintf(description, sizeof(description), "区域 %d", i + 1);
if (perform_munlock(config.addresses[i], config.sizes[i],
config.verbose ? description : NULL) != 0) {
result = -1;
}
}
} else if (!config.show_status && !config.test_mode) {
// 没有指定操作，显示帮助
show_help(argv[0]);
return 0;
}
// 显示操作后状态
if (config.show_status) {
printf("=== 操作后状态 ===\n");
show_system_memory_info();
}
// 清理资源
if (config.addresses) {
free(config.addresses);
}
if (config.sizes) {
free(config.sizes);
}
// 显示使用建议
printf("\n=== 内存解锁使用建议 ===\n");
printf("适用场景:\n");
printf("1. 实时应用结束后释放锁定内存\n");
printf("2. 内存压力大时释放不必要的锁定\n");
printf("3. 程序退出前清理资源\n");
printf("4. 动态调整内存锁定策略\n");
printf("\n");
printf("最佳实践:\n");
printf("1. 及时解锁不需要的锁定内存\n");
printf("2. 避免内存锁定泄漏\n");
printf("3. 监控系统内存使用情况\n");
printf("4. 在异常处理中包含解锁操作\n");
printf("5. 使用 munlockall 简化清理工作\n");
printf("\n");
printf("注意事项:\n");
printf("1. munlock 操作不需要特殊权限\n");
printf("2. 解锁已解锁的内存不会出错\n");
printf("3. munlockall 会解锁进程的所有内存\n");
printf("4. 应该在程序结束时调用 munlockall\n");
return (result == 0) ? 0 : 1;
}
编译和运行说明
链接到标题
# 编译示例程序
gcc -o munlock_example1 example1.c
gcc -o munlock_example2 example2.c -lpthread
gcc -o munlock_example3 example3.c -lpthread
# 运行示例
./munlock_example1
./munlock_example2
./munlock_example3 --help
# 基本操作
./munlock_example3 -s
./munlock_example3 -a
./munlock_example3 -t 20
# 需要权限的测试（使用 sudo）
sudo ./munlock_example3 -t 100
系统要求检查
链接到标题
# 检查系统支持
grep -i mlock /boot/config-$(uname -r)
# 检查当前内存锁定限制
ulimit -l
# 查看系统内存信息
cat /proc/meminfo
free -h
# 检查当前进程的内存锁定状态
cat /proc/self/status | grep -i vmlck
重要注意事项
链接到标题
权限要求: munlock 和 munlockall 不需要特殊权限
错误处理: 解锁已解锁的内存不会出错
资源管理: 应该及时解锁不需要的锁定内存
清理责任: 程序结束时应该调用 munlockall
内存释放: 解锁后仍需 free 释放内存
实际应用场景
链接到标题
实时系统: 应用结束时释放锁定内存
高性能计算: 动态调整内存锁定策略
游戏引擎: 资源管理优化
数据库系统: 内存管理优化
科学计算: 大规模内存操作管理
最佳实践
链接到标题
// 安全的内存解锁函数
int safe_munlock(const void *addr, size_t len) {
// 验证参数
if (!addr || len == 0) {
errno = EINVAL;
return -1;
}
// 执行解锁
int result = munlock(addr, len);
// 处理常见情况
if (result == -1) {
switch (errno) {
case ENOMEM:
// 地址范围无效，可能已经释放
fprintf(stderr, "警告: 内存地址范围无效\n");
break;
case EINVAL:
fprintf(stderr, "警告: 无效的地址或长度参数\n");
break;
}
}
return result;
}
// 程序退出时的清理函数
void cleanup_memory_locking() {
// 解锁所有内存
if (munlockall() == 0) {
printf("内存锁定已清理\n");
} else {
perror("清理内存锁定失败");
}
// 可以在这里添加其他清理操作
}
// RAII 风格的内存锁定管理
typedef struct {
void *addr;
size_t size;
int locked;
} memory_lock_t;
int memory_lock_init(memory_lock_t *lock, void *addr, size_t size) {
lock->addr = addr;
lock->size = size;
lock->locked = 0;
if (mlock(addr, size) == 0) {
lock->locked = 1;
return 0;
}
return -1;
}
void memory_lock_destroy(memory_lock_t *lock) {
if (lock->locked) {
munlock(lock->addr, lock->size);
lock->locked = 0;
}
}
这些示例展示了 munlock 和 munlockall 函数的各种使用方法，从基础的内存解锁到完整的管理工具，帮助你全面掌握 Linux 系统中的内存解锁机制。