munmap：内存映射的优雅清理者

munmap：内存映射的优雅清理者

<摘要>
munmap是Unix/Linux系统中用于解除内存映射的系统调用，它就像一位细心的清洁工，负责清理mmap创建的内存映射区域。通过munmap，程序可以安全地释放映射的内存空间，确保系统资源的正确回收。这个函数在文件操作、内存管理和进程间通信等场景中扮演着至关重要的角色。本文将用生动的比喻和实际案例，带你深入理解这个内存管理的守护者。

---

<正文>

1. 基本概念与用途：内存的环保回收

想象一下，你租用了一个大型仓库（内存映射区域）来临时存放货物（数据）。当你完成工作后，需要将这个仓库归还给房东（操作系统）。如果你只是简单地离开而不办理退租手续，仓库可能会一直占用，导致资源浪费。

在Linux系统中，munmap就是这样一个"退租手续办理员"，它负责：

• 正式解除内存映射关系
• 同步数据到文件（如果使用MAP_SHARED）
• 释放虚拟内存资源
• 更新内核的页表

生动比喻：图书馆的书籍归还

mmap映射过程：

• 从图书馆借书到你的书房（文件映射到内存）
• 你可以在书房直接阅读和批注（内存中访问文件数据）
• 批注会自动同步到图书馆的原书（MAP_SHARED）

munmap解除映射：

• 将书归还给图书馆（解除内存映射）
• 确保所有批注都保存到原书（数据同步）
• 清理书房空间（释放虚拟内存）

常见使用场景

• 文件操作完成后：关闭映射的文件，释放内存资源
• 动态内存管理：释放通过mmap分配的大内存块
• 进程间通信：清理共享内存区域
• 资源清理：程序退出前的内存映射清理
• 错误处理：映射失败时的资源回收
• 内存池管理：释放自定义内存池的映射空间

2. 函数声明与来源

munmap函数定义在sys/mman.h头文件中，属于POSIX标准的一部分。

#include <sys/mman.h>

int munmap(void *addr, size_t length);

这个简洁的声明背后是复杂的内存管理逻辑！让我们用mermaid图来展示它的核心工作机制：

3. 参数详解：精准释放的双要素

参数1：addr - 映射区域的起始地址

• 类型：void*
• 含义：要解除映射的内存区域的起始地址
• 实际意义：指向要"退租仓库"的大门位置
• 关键要求：必须是mmap返回的地址，或者是该地址所在页的边界
• 重要提示：地址必须页对齐（通常是4096字节的倍数）

参数2：length - 要解除映射的区域长度

• 类型：size_t
• 含义：要解除映射的字节数
• 实际意义：要"退租仓库"的大小
• 重要特性：
  • 长度会被向上取整到页大小的倍数
  • 可以只解除部分映射区域
  • 如果为0，系统会解除整个映射区域

参数对齐的重要性

由于内存管理基于页（通常4KB），munmap操作总是以页为单位：

// 正确的用法：页对齐的地址和长度
void* addr = mmap(NULL, length, PROT_READ, MAP_PRIVATE, fd, 0);
munmap(addr, length);  // addr已经是页对齐的

// 错误的用法：非页对齐的地址
void* addr = mmap(NULL, length, PROT_READ, MAP_PRIVATE, fd, 0);
munmap(addr + 100, length - 100);  // 错误！地址没有页对齐

4. 返回值的含义：清理结果的成绩单

成功情况

返回0，表示成功解除内存映射，相关资源已被释放。

失败情况

返回-1，并设置errno指示错误原因。

常见错误码

• EINVAL：无效参数（地址未页对齐、长度无效等）
• ENOMEM：指定地址范围不在映射区域内
• EFAULT：地址指向无效的内存区域

让我们通过一个更详细的流程图来理解munmap的完整工作过程：

5. 实例与应用场景：让理论落地生根

案例1：安全文件映射管理器

应用场景：开发一个需要安全处理大型文件的应用程序，确保在程序异常或正常退出时都能正确清理内存映射。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

/**
 * @brief 文件映射管理器
 * 
 * 安全地管理文件映射，确保资源正确释放。
 */
typedef struct {
    void* mapped_addr;
    size_t mapped_size;
    int is_mapped;
    char* filename;
} file_mapping_t;

/**
 * @brief 初始化文件映射管理器
 * 
 * @param filename 要映射的文件名
 * @return file_mapping_t* 映射管理器对象
 */
file_mapping_t* file_mapping_init(const char* filename) {
    file_mapping_t* mapping = malloc(sizeof(file_mapping_t));
    if (!mapping) {
        return NULL;
    }
    
    mapping->mapped_addr = NULL;
    mapping->mapped_size = 0;
    mapping->is_mapped = 0;
    mapping->filename = strdup(filename);
    
    printf("文件映射管理器初始化: %s\n", filename);
    return mapping;
}

/**
 * @brief 安全地映射文件到内存
 * 
 * @param mapping 映射管理器
 * @param writable 是否可写
 * @return int 成功返回0，失败返回-1
 */
int file_mapping_map(file_mapping_t* mapping, int writable) {
    if (!mapping || mapping->is_mapped) {
        fprintf(stderr, "映射管理器无效或已映射\n");
        return -1;
    }
    
    // 打开文件
    int fd = open(mapping->filename, writable ? O_RDWR : O_RDONLY);
    if (fd == -1) {
        perror("打开文件失败");
        return -1;
    }
    
    // 获取文件大小
    struct stat sb;
    if (fstat(fd, &sb) == -1) {
        perror("获取文件状态失败");
        close(fd);
        return -1;
    }
    
    if (sb.st_size == 0) {
        fprintf(stderr, "文件为空\n");
        close(fd);
        return -1;
    }
    
    // 创建内存映射
    int prot = writable ? (PROT_READ | PROT_WRITE) : PROT_READ;
    int flags = writable ? MAP_SHARED : MAP_PRIVATE;
    
    mapping->mapped_addr = mmap(NULL, sb.st_size, prot, flags, fd, 0);
    close(fd);  // 映射建立后可以关闭文件描述符
    
    if (mapping->mapped_addr == MAP_FAILED) {
        perror("内存映射失败");
        mapping->mapped_addr = NULL;
        return -1;
    }
    
    mapping->mapped_size = sb.st_size;
    mapping->is_mapped = 1;
    
    printf("成功映射文件: %s, 地址: %p, 大小: %zu 字节\n", 
           mapping->filename, mapping->mapped_addr, mapping->mapped_size);
    
    return 0;
}

/**
 * @brief 安全地解除文件映射
 * 
 * @param mapping 映射管理器
 * @return int 成功返回0，失败返回-1
 */
int file_mapping_unmap(file_mapping_t* mapping) {
    if (!mapping || !mapping->is_mapped) {
        fprintf(stderr, "映射管理器无效或未映射\n");
        return -1;
    }
    
    printf("正在解除文件映射: %s\n", mapping->filename);
    
    // 对于可写的MAP_SHARED映射，确保数据同步
    if (mapping->is_mapped) {
        // 可以使用msync确保数据写回文件
        if (msync(mapping->mapped_addr, mapping->mapped_size, MS_SYNC) == -1) {
            perror("msync失败");
            // 继续执行munmap，不因此失败
        }
        
        // 解除内存映射
        if (munmap(mapping->mapped_addr, mapping->mapped_size) == -1) {
            perror("munmap失败");
            return -1;
        }
        
        printf("成功解除映射: %s\n", mapping->filename);
        
        mapping->mapped_addr = NULL;
        mapping->mapped_size = 0;
        mapping->is_mapped = 0;
    }
    
    return 0;
}

/**
 * @brief 销毁映射管理器
 * 
 * @param mapping 映射管理器
 */
void file_mapping_destroy(file_mapping_t* mapping) {
    if (mapping) {
        // 确保在销毁前解除映射
        if (mapping->is_mapped) {
            file_mapping_unmap(mapping);
        }
        
        free(mapping->filename);
        free(mapping);
        printf("映射管理器已销毁\n");
    }
}

/**
 * @brief 在映射内存中搜索字符串
 * 
 * @param mapping 映射管理器
 * @param search_str 要搜索的字符串
 * @return void* 找到的位置指针，未找到返回NULL
 */
void* file_mapping_search(file_mapping_t* mapping, const char* search_str) {
    if (!mapping || !mapping->is_mapped) {
        return NULL;
    }
    
    size_t search_len = strlen(search_str);
    if (search_len == 0) {
        return NULL;
    }
    
    // 在映射的内存中搜索
    char* found = memmem(mapping->mapped_addr, mapping->mapped_size, 
                        search_str, search_len);
    
    if (found) {
        size_t offset = found - (char*)mapping->mapped_addr;
        printf("找到字符串 '%s' 在偏移量 %zu 处\n", search_str, offset);
    } else {
        printf("未找到字符串 '%s'\n", search_str);
    }
    
    return found;
}

/**
 * @brief 演示资源泄漏检测
 * 
 * 展示如果不使用munmap会导致的问题。
 */
void demonstrate_resource_leak() {
    printf("\n资源泄漏演示:\n");
    printf("==============\n");
    
    // 故意创建映射但不释放，模拟资源泄漏
    int fd = open("/etc/passwd", O_RDONLY);
    if (fd != -1) {
        struct stat sb;
        fstat(fd, &sb);
        
        void* addr = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
        if (addr != MAP_FAILED) {
            printf("创建映射但不释放: %p\n", addr);
            // 注意：这里故意不调用munmap来演示资源泄漏
        }
        close(fd);
    }
    
    printf("注意: 上面的映射没有被释放，会导致资源泄漏!\n");
}

int main() {
    printf("安全文件映射管理器演示\n");
    printf("=====================\n");
    
    // 初始化映射管理器
    file_mapping_t* mapping = file_mapping_init("/etc/passwd");
    if (!mapping) {
        return 1;
    }
    
    // 映射文件（只读）
    if (file_mapping_map(mapping, 0) != 0) {
        file_mapping_destroy(mapping);
        return 1;
    }
    
    // 在映射的内存中搜索
    file_mapping_search(mapping, "root");
    file_mapping_search(mapping, "nobody");
    file_mapping_search(mapping, "nonexistent_string");
    
    // 安全地解除映射
    if (file_mapping_unmap(mapping) != 0) {
        file_mapping_destroy(mapping);
        return 1;
    }
    
    // 演示重新映射（可写）
    printf("\n重新映射为可写模式:\n");
    if (file_mapping_map(mapping, 1) == 0) {
        // 可以在这里修改映射的内存
        printf("文件现在以可写模式映射\n");
        
        // 安全解除映射
        file_mapping_unmap(mapping);
    }
    
    // 清理资源
    file_mapping_destroy(mapping);
    
    // 演示资源泄漏
    demonstrate_resource_leak();
    
    return 0;
}

编译与运行：

创建Makefile：

CC = gcc
CFLAGS = -Wall -g -O2
TARGET = munmap_demo
SOURCES = munmap_demo.c

all: $(TARGET)

$(TARGET): $(SOURCES)
	$(CC) $(CFLAGS) -o $(TARGET) $(SOURCES)

clean:
	rm -f $(TARGET)

run: $(TARGET)
	./$(TARGET)

.PHONY: all clean run

编译方法：

make

运行程序：

./munmap_demo

运行结果解读：

安全文件映射管理器演示
=====================
文件映射管理器初始化: /etc/passwd
成功映射文件: /etc/passwd, 地址: 0x7f8a5b2b5000, 大小: 2805 字节
找到字符串 'root' 在偏移量 0 处
找到字符串 'nobody' 在偏移量 2520 处
未找到字符串 'nonexistent_string'
正在解除文件映射: /etc/passwd
成功解除映射: /etc/passwd

重新映射为可写模式:
成功映射文件: /etc/passwd, 地址: 0x7f8a5b2a4000, 大小: 2805 字节
文件现在以可写模式映射
正在解除文件映射: /etc/passwd
成功解除映射: /etc/passwd
映射管理器已销毁

资源泄漏演示:
==============
创建映射但不释放: 0x7f8a5b293000
注意: 上面的映射没有被释放，会导致资源泄漏!

案例2：内存池分配器

应用场景：开发一个高性能的内存池，使用mmap分配大块内存，然后进行细粒度管理，最后使用munmap统一释放。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>
#include <errno.h>

/**
 * @brief 内存块头结构
 */
typedef struct mem_block {
    size_t size;
    int free;
    struct mem_block* next;
} mem_block_t;

#define POOL_SIZE (1024 * 1024)  // 1MB
#define BLOCK_MIN_SIZE 16

/**
 * @brief 内存池分配器
 */
typedef struct {
    void* pool_start;
    void* pool_current;
    size_t pool_size;
    size_t used_size;
    mem_block_t* free_list;
} mem_pool_t;

/**
 * @brief 使用mmap创建内存池
 * 
 * @param size 内存池大小
 * @return mem_pool_t* 内存池对象
 */
mem_pool_t* mem_pool_create(size_t size) {
    mem_pool_t* pool = malloc(sizeof(mem_pool_t));
    if (!pool) {
        return NULL;
    }
    
    // 使用mmap分配内存
    pool->pool_start = mmap(NULL, size, 
                           PROT_READ | PROT_WRITE,
                           MAP_PRIVATE | MAP_ANONYMOUS,
                           -1, 0);
    
    if (pool->pool_start == MAP_FAILED) {
        perror("mmap失败");
        free(pool);
        return NULL;
    }
    
    pool->pool_size = size;
    pool->pool_current = pool->pool_start;
    pool->used_size = 0;
    
    // 初始化第一个空闲块
    mem_block_t* first_block = (mem_block_t*)pool->pool_start;
    first_block->size = size - sizeof(mem_block_t);
    first_block->free = 1;
    first_block->next = NULL;
    
    pool->free_list = first_block;
    
    printf("创建内存池: 地址=%p, 大小=%zu\n", pool->pool_start, size);
    return pool;
}

/**
 * @brief 从内存池分配内存
 * 
 * @param pool 内存池
 * @param size 请求大小
 * @return void* 分配的内存地址
 */
void* mem_pool_alloc(mem_pool_t* pool, size_t size) {
    if (!pool || size == 0) {
        return NULL;
    }
    
    // 对齐到8字节
    size = (size + 7) & ~7;
    
    mem_block_t* current = pool->free_list;
    mem_block_t* prev = NULL;
    
    // 首次适应算法
    while (current) {
        if (current->free && current->size >= size) {
            // 检查是否需要分割块
            if (current->size >= size + sizeof(mem_block_t) + BLOCK_MIN_SIZE) {
                // 分割块
                mem_block_t* new_block = (mem_block_t*)((char*)current + sizeof(mem_block_t) + size);
                new_block->size = current->size - size - sizeof(mem_block_t);
                new_block->free = 1;
                new_block->next = current->next;
                
                current->size = size;
                current->next = new_block;
            }
            
            current->free = 0;
            
            // 从空闲链表移除
            if (prev) {
                prev->next = current->next;
            } else {
                pool->free_list = current->next;
            }
            
            pool->used_size += size + sizeof(mem_block_t);
            
            printf("分配内存: %p, 大小: %zu\n", 
                   (void*)(current + 1), current->size);
            
            return (void*)(current + 1);
        }
        
        prev = current;
        current = current->next;
    }
    
    printf("内存分配失败: 请求大小 %zu\n", size);
    return NULL;
}

/**
 * @brief 释放内存回内存池
 * 
 * @param pool 内存池
 * @param ptr 要释放的内存指针
 */
void mem_pool_free(mem_pool_t* pool, void* ptr) {
    if (!pool || !ptr) {
        return;
    }
    
    mem_block_t* block = (mem_block_t*)ptr - 1;
    
    printf("释放内存: %p, 大小: %zu\n", ptr, block->size);
    
    block->free = 1;
    pool->used_size -= block->size + sizeof(mem_block_t);
    
    // 合并相邻的空闲块
    mem_block_t* current = (mem_block_t*)pool->pool_start;
    while (current) {
        if (current->free && current->next && current->next->free) {
            // 合并当前块和下一个块
            current->size += sizeof(mem_block_t) + current->next->size;
            current->next = current->next->next;
        } else {
            current = current->next;
        }
    }
    
    // 简化：将释放的块添加到空闲链表头部
    block->next = pool->free_list;
    pool->free_list = block;
}

/**
 * @brief 使用munmap销毁内存池
 * 
 * @param pool 内存池
 * @return int 成功返回0，失败返回-1
 */
int mem_pool_destroy(mem_pool_t* pool) {
    if (!pool) {
        return -1;
    }
    
    printf("销毁内存池: 地址=%p, 总大小=%zu, 已使用=%zu\n",
           pool->pool_start, pool->pool_size, pool->used_size);
    
    if (pool->pool_start && pool->pool_start != MAP_FAILED) {
        // 使用munmap释放映射的内存
        if (munmap(pool->pool_start, pool->pool_size) == -1) {
            perror("munmap失败");
            free(pool);
            return -1;
        }
        printf("成功释放映射的内存\n");
    }
    
    free(pool);
    return 0;
}

/**
 * @brief 显示内存池状态
 * 
 * @param pool 内存池
 */
void mem_pool_status(const mem_pool_t* pool) {
    if (!pool) {
        return;
    }
    
    printf("\n内存池状态:\n");
    printf("起始地址: %p\n", pool->pool_start);
    printf("总大小: %zu bytes\n", pool->pool_size);
    printf("已使用: %zu bytes\n", pool->used_size);
    printf("利用率: %.1f%%\n", (double)pool->used_size / pool->pool_size * 100);
    
    printf("空闲链表:\n");
    mem_block_t* current = pool->free_list;
    while (current) {
        printf("  块: %p, 大小: %zu, 状态: %s\n",
               current, current->size, current->free ? "空闲" : "使用中");
        current = current->next;
    }
}

int main() {
    printf("内存池分配器演示\n");
    printf("================\n");
    
    // 创建内存池
    mem_pool_t* pool = mem_pool_create(POOL_SIZE);
    if (!pool) {
        return 1;
    }
    
    // 分配一些内存块
    void* ptr1 = mem_pool_alloc(pool, 100);
    void* ptr2 = mem_pool_alloc(pool, 200);
    void* ptr3 = mem_pool_alloc(pool, 50);
    
    if (ptr1) memset(ptr1, 'A', 100);
    if (ptr2) memset(ptr2, 'B', 200);
    if (ptr3) memset(ptr3, 'C', 50);
    
    mem_pool_status(pool);
    
    // 释放一些内存块
    printf("\n释放部分内存块:\n");
    mem_pool_free(pool, ptr2);
    mem_pool_status(pool);
    
    // 分配更多内存
    printf("\n分配更多内存:\n");
    void* ptr4 = mem_pool_alloc(pool, 150);
    if (ptr4) memset(ptr4, 'D', 150);
    mem_pool_status(pool);
    
    // 清理所有内存
    printf("\n清理所有内存:\n");
    mem_pool_free(pool, ptr1);
    mem_pool_free(pool, ptr3);
    mem_pool_free(pool, ptr4);
    mem_pool_status(pool);
    
    // 销毁内存池
    printf("\n销毁内存池:\n");
    if (mem_pool_destroy(pool) == 0) {
        printf("内存池成功销毁\n");
    } else {
        printf("内存池销毁失败\n");
    }
    
    return 0;
}

程序流程图：

案例3：进程间共享内存管理

应用场景：开发一个进程间通信系统，使用共享内存进行高效数据交换，并确保在进程退出时正确清理共享内存。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>

/**
 * @brief 共享内存数据结构
 */
typedef struct {
    int data_ready;
    int counter;
    char message[256];
} shared_data_t;

#define SHM_NAME "/demo_shared_memory"

/**
 * @brief 共享内存管理器
 */
typedef struct {
    char* shm_name;
    void* shm_addr;
    size_t shm_size;
    int shm_fd;
    int is_owner;
} shm_manager_t;

/**
 * @brief 创建或打开共享内存
 * 
 * @param name 共享内存名称
 * @param size 共享内存大小
 * @param owner 是否是创建者
 * @return shm_manager_t* 共享内存管理器
 */
shm_manager_t* shm_manager_create(const char* name, size_t size, int owner) {
    shm_manager_t* manager = malloc(sizeof(shm_manager_t));
    if (!manager) {
        return NULL;
    }
    
    manager->shm_name = strdup(name);
    manager->shm_size = size;
    manager->is_owner = owner;
    manager->shm_addr = NULL;
    manager->shm_fd = -1;
    
    // 创建或打开共享内存对象
    if (owner) {
        // 创建者：创建新的共享内存对象
        manager->shm_fd = shm_open(name, O_CREAT | O_RDWR, 0644);
        if (manager->shm_fd == -1) {
            perror("shm_open创建失败");
            free(manager->shm_name);
            free(manager);
            return NULL;
        }
        
        // 设置共享内存大小
        if (ftruncate(manager->shm_fd, size) == -1) {
            perror("ftruncate失败");
            close(manager->shm_fd);
            shm_unlink(name);
            free(manager->shm_name);
            free(manager);
            return NULL;
        }
        
        printf("创建共享内存: %s, 大小: %zu\n", name, size);
    } else {
        // 使用者：打开现有的共享内存对象
        manager->shm_fd = shm_open(name, O_RDWR, 0);
        if (manager->shm_fd == -1) {
            perror("shm_open打开失败");
            free(manager->shm_name);
            free(manager);
            return NULL;
        }
        
        printf("打开共享内存: %s\n", name);
    }
    
    // 映射共享内存
    manager->shm_addr = mmap(NULL, size, 
                            PROT_READ | PROT_WRITE,
                            MAP_SHARED, manager->shm_fd, 0);
    
    if (manager->shm_addr == MAP_FAILED) {
        perror("mmap共享内存失败");
        if (owner) {
            shm_unlink(name);
        }
        close(manager->shm_fd);
        free(manager->shm_name);
        free(manager);
        return NULL;
    }
    
    printf("映射共享内存: 地址=%p\n", manager->shm_addr);
    
    // 如果是创建者，初始化共享数据
    if (owner) {
        shared_data_t* data = (shared_data_t*)manager->shm_addr;
        memset(data, 0, sizeof(shared_data_t));
        data->data_ready = 0;
        data->counter = 0;
        strcpy(data->message, "初始消息");
    }
    
    return manager;
}

/**
 * @brief 安全地解除共享内存映射
 * 
 * @param manager 共享内存管理器
 * @return int 成功返回0，失败返回-1
 */
int shm_manager_unmap(shm_manager_t* manager) {
    if (!manager || !manager->shm_addr) {
        return -1;
    }
    
    printf("解除共享内存映射: %s\n", manager->shm_name);
    
    // 解除内存映射
    if (munmap(manager->shm_addr, manager->shm_size) == -1) {
        perror("munmap共享内存失败");
        return -1;
    }
    
    manager->shm_addr = NULL;
    
    // 关闭文件描述符
    if (manager->shm_fd != -1) {
        close(manager->shm_fd);
        manager->shm_fd = -1;
    }
    
    printf("成功解除共享内存映射\n");
    return 0;
}

/**
 * @brief 销毁共享内存管理器
 * 
 * @param manager 共享内存管理器
 * @return int 成功返回0，失败返回-1
 */
int shm_manager_destroy(shm_manager_t* manager) {
    if (!manager) {
        return -1;
    }
    
    printf("销毁共享内存管理器: %s\n", manager->shm_name);
    
    // 先解除映射
    shm_manager_unmap(manager);
    
    // 如果是创建者，删除共享内存对象
    if (manager->is_owner) {
        if (shm_unlink(manager->shm_name) == -1) {
            perror("shm_unlink失败");
            // 继续执行，不因此失败
        } else {
            printf("删除共享内存对象: %s\n", manager->shm_name);
        }
    }
    
    free(manager->shm_name);
    free(manager);
    
    printf("共享内存管理器已销毁\n");
    return 0;
}

/**
 * @brief 写入共享数据
 * 
 * @param manager 共享内存管理器
 * @param message 消息内容
 * @return int 成功返回0，失败返回-1
 */
int shm_write_data(shm_manager_t* manager, const char* message) {
    if (!manager || !manager->shm_addr) {
        return -1;
    }
    
    shared_data_t* data = (shared_data_t*)manager->shm_addr;
    
    data->counter++;
    strncpy(data->message, message, sizeof(data->message) - 1);
    data->data_ready = 1;
    
    printf("写入共享数据: 计数器=%d, 消息=%s\n", data->counter, data->message);
    return 0;
}

/**
 * @brief 读取共享数据
 * 
 * @param manager 共享内存管理器
 * @return int 成功返回0，失败返回-1
 */
int shm_read_data(shm_manager_t* manager) {
    if (!manager || !manager->shm_addr) {
        return -1;
    }
    
    shared_data_t* data = (shared_data_t*)manager->shm_addr;
    
    if (data->data_ready) {
        printf("读取共享数据: 计数器=%d, 消息=%s\n", data->counter, data->message);
        data->data_ready = 0;  // 标记为已读取
        return 0;
    } else {
        printf("没有新的共享数据\n");
        return 1;
    }
}

/**
 * @brief 信号处理函数
 */
volatile sig_atomic_t shm_running = 1;

void signal_handler(int sig) {
    shm_running = 0;
    printf("\n收到信号 %d, 正在清理...\n", sig);
}

/**
 * @brief 演示共享内存的使用
 */
void demo_shared_memory() {
    printf("共享内存演示\n");
    printf("============\n");
    
    // 注册信号处理
    signal(SIGINT, signal_handler);
    signal(SIGTERM, signal_handler);
    
    // 创建共享内存（作为创建者）
    shm_manager_t* manager = shm_manager_create(SHM_NAME, sizeof(shared_data_t), 1);
    if (!manager) {
        return;
    }
    
    printf("\n共享内存使用演示 (按Ctrl+C退出):\n");
    
    int counter = 0;
    while (shm_running) {
        // 写入数据
        char message[256];
        snprintf(message, sizeof(message), "消息 #%d", ++counter);
        shm_write_data(manager, message);
        
        sleep(2);
        
        // 读取数据（模拟其他进程的读取）
        shm_read_data(manager);
        
        sleep(1);
    }
    
    // 清理共享内存
    printf("\n正在清理共享内存...\n");
    shm_manager_destroy(manager);
}

int main() {
    printf("munmap共享内存管理演示\n");
    printf("=====================\n");
    
    demo_shared_memory();
    
    return 0;
}

时序图展示共享内存管理过程：

6. 进阶技巧与最佳实践

错误处理最佳实践

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <errno.h>

/**
 * @brief 安全的munmap包装函数
 * 
 * 提供更好的错误处理和日志记录。
 * 
 * @param addr 映射地址
 * @param length 映射长度
 * @param description 描述信息（用于日志）
 * @return int 成功返回0，失败返回-1
 */
int safe_munmap(void* addr, size_t length, const char* description) {
    if (!addr || length == 0) {
        fprintf(stderr, "错误: 无效的munmap参数\n");
        return -1;
    }
    
    printf("正在解除映射: %s (地址: %p, 大小: %zu)\n", 
           description, addr, length);
    
    // 对于可写的MAP_SHARED映射，建议先同步数据
    if (msync(addr, length, MS_SYNC) == -1) {
        // msync失败不一定是严重错误，记录但继续
        perror("警告: msync失败");
    }
    
    if (munmap(addr, length) == -1) {
        switch (errno) {
            case EINVAL:
                fprintf(stderr, "错误: 无效参数 (地址未页对齐或长度无效)\n");
                break;
            case ENOMEM:
                fprintf(stderr, "错误: 指定地址范围不在映射区域内\n");
                break;
            default:
                perror("munmap失败");
                break;
        }
        return -1;
    }
    
    printf("成功解除映射: %s\n", description);
    return 0;
}

/**
 * @brief RAII风格的内存映射包装器
 */
typedef struct {
    void* addr;
    size_t length;
    const char* description;
} auto_mapping_t;

/**
 * @brief 创建自动管理的映射
 * 
 * @param addr 映射地址（NULL表示自动选择）
 * @param length 映射长度
 * @param prot 保护权限
 * @param flags 映射标志
 * @param fd 文件描述符
 * @param offset 文件偏移
 * @param description 描述信息
 * @return auto_mapping_t 自动映射对象
 */
auto_mapping_t auto_mmap(void* addr, size_t length, int prot, int flags,
                        int fd, off_t offset, const char* description) {
    auto_mapping_t mapping;
    mapping.addr = mmap(addr, length, prot, flags, fd, offset);
    mapping.length = length;
    mapping.description = description;
    
    if (mapping.addr == MAP_FAILED) {
        perror("mmap失败");
        mapping.addr = NULL;
        mapping.length = 0;
    } else {
        printf("创建自动映射: %s (地址: %p, 大小: %zu)\n", 
               description, mapping.addr, length);
    }
    
    return mapping;
}

/**
 * @brief 自动解除映射（用于RAII模式）
 * 
 * @param mapping 自动映射对象
 */
void auto_munmap(auto_mapping_t* mapping) {
    if (mapping && mapping->addr && mapping->length > 0) {
        safe_munmap(mapping->addr, mapping->length, mapping->description);
        mapping->addr = NULL;
        mapping->length = 0;
    }
}

性能优化技巧

1. 批量操作减少系统调用：

// 对于多个相关的映射，可以批量处理
void cleanup_multiple_mappings(void** addresses, size_t* lengths, int count) {
    for (int i = 0; i < count; i++) {
        if (addresses[i] && lengths[i] > 0) {
            munmap(addresses[i], lengths[i]);
            addresses[i] = NULL;
            lengths[i] = 0;
        }
    }
}

2. 部分解除映射：

// 只解除部分映射区域（需要页对齐）
void partial_unmap(void* full_addr, size_t full_length, 
                   size_t keep_offset, size_t keep_length) {
    // 计算要解除映射的区域
    void* unmap_addr = (char*)full_addr + keep_offset + keep_length;
    size_t unmap_length = full_length - keep_offset - keep_length;
    
    if (unmap_length > 0) {
        // 注意：地址必须页对齐
        void* page_aligned_addr = (void*)((uintptr_t)unmap_addr & ~(getpagesize() - 1));
        size_t page_aligned_length = unmap_length + ((char*)unmap_addr - (char*)page_aligned_addr);
        
        munmap(page_aligned_addr, page_aligned_length);
    }
}

3. 内存映射的生命周期管理：

// 使用引用计数管理共享映射
typedef struct {
    void* addr;
    size_t length;
    int ref_count;
    pthread_mutex_t lock;
} shared_mapping_t;

shared_mapping_t* shared_mapping_add_ref(shared_mapping_t* mapping) {
    pthread_mutex_lock(&mapping->lock);
    mapping->ref_count++;
    pthread_mutex_unlock(&mapping->lock);
    return mapping;
}

void shared_mapping_release(shared_mapping_t* mapping) {
    pthread_mutex_lock(&mapping->lock);
    mapping->ref_count--;
    if (mapping->ref_count == 0) {
        pthread_mutex_unlock(&mapping->lock);
        munmap(mapping->addr, mapping->length);
        free(mapping);
    } else {
        pthread_mutex_unlock(&mapping->lock);
    }
}

7. 现代替代与发展

与C++ RAII模式的结合

在现代C++中，可以使用RAII（Resource Acquisition Is Initialization）模式自动管理内存映射：

#include <iostream>
#include <system_error>
#include <sys/mman.h>

class MappedFile {
private:
    void* data_ = nullptr;
    size_t size_ = 0;
    std::string filename_;
    
public:
    MappedFile(const std::string& filename, bool writable = false) 
        : filename_(filename) {
        // 打开文件和映射（简化示例）
        int fd = open(filename.c_str(), writable ? O_RDWR : O_RDONLY);
        if (fd == -1) {
            throw std::system_error(errno, std::system_category());
        }
        
        struct stat sb;
        if (fstat(fd, &sb) == -1) {
            close(fd);
            throw std::system_error(errno, std::system_category());
        }
        
        size_ = sb.st_size;
        int prot = writable ? (PROT_READ | PROT_WRITE) : PROT_READ;
        int flags = writable ? MAP_SHARED : MAP_PRIVATE;
        
        data_ = mmap(nullptr, size_, prot, flags, fd, 0);
        close(fd);
        
        if (data_ == MAP_FAILED) {
            throw std::system_error(errno, std::system_category());
        }
        
        std::cout << "映射文件: " << filename_ << " (" << size_ << " 字节)" << std::endl;
    }
    
    // 禁止拷贝
    MappedFile(const MappedFile&) = delete;
    MappedFile& operator=(const MappedFile&) = delete;
    
    // 允许移动
    MappedFile(MappedFile&& other) noexcept 
        : data_(other.data_), size_(other.size_), filename_(std::move(other.filename_)) {
        other.data_ = nullptr;
        other.size_ = 0;
    }
    
    ~MappedFile() {
        if (data_ && data_ != MAP_FAILED) {
            std::cout << "自动解除映射: " << filename_ << std::endl;
            munmap(data_, size_);
        }
    }
    
    void* data() const { return data_; }
    size_t size() const { return size_; }
    
    // 同步数据到磁盘
    void sync() {
        if (msync(data_, size_, MS_SYNC) == -1) {
            throw std::system_error(errno, std::system_category());
        }
    }
};

// 使用示例
int main() {
    try {
        MappedFile file("example.txt", true);
        // 使用file.data()访问映射的内存
        // 析构时自动调用munmap
    } catch (const std::system_error& e) {
        std::cerr << "错误: " << e.what() << std::endl;
    }
    return 0;
}

在现代系统中的应用

虽然现代高级语言提供了更简单的内存管理抽象，但在系统编程中，munmap仍然很重要：

1. 数据库系统：管理内存映射的数据文件和索引
2. 高性能服务器：处理大文件的内存映射和清理
3. 虚拟化技术：管理客户机的内存映射
4. 容器运行时：清理容器进程的内存映射
5. 内存分析工具：安全地解除临时映射

8. 总结

通过本文的详细讲解，相信你已经对munmap系统调用有了全面的理解。让我们用最后一个总结图来回顾munmap的核心特性：

munmap是Unix/Linux系统编程中一个基础但至关重要的工具，它确保了内存映射资源的正确清理和系统资源的有效回收。虽然在使用上相对简单，但正确的munmap使用对于构建稳定、高效的应用程序至关重要。

记住，每次成功的mmap调用都应该对应一次munmap调用，这是良好内存管理的基本准则。通过掌握munmap，你不仅能够避免内存泄漏，还能构建出更加健壮和可靠的系统软件。

希望本文能帮助你在实际项目中更好地理解和运用这个内存管理的守护者！