Linux使用mmap实现父子进程间的通信_Linux

引言

在linux系统中，进程间通信(ipc)是编程中常见的需求。传统的ipc方式包括管道、消息队列、共享内存、信号量等。其中，共享内存是一种高效的ipc方式，因为它允许不同进程直接读写同一块内存区域，而不需要内核的介入。mmap(memory map)函数可以将文件映射到进程的地址空间，也可以用于创建匿名映射，从而实现进程间的内存共享。本文将详细介绍如何在linux中使用mmap实现父子进程间的通信。

一、mmap基本概念

mmap是linux系统提供的一个系统调用，用于将文件或设备映射到进程的地址空间。通过mmap，进程可以像访问内存一样访问文件或设备，而无需使用传统的read/write系统调用。

mmap函数原型如下：

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

参数说明：

addr：指定映射的起始地址，通常设为null让系统自动选择
length：映射区域的长度
prot：保护标志，如prot_read(可读)、prot_write(可写)等
flags：映射类型标志，如map_shared(共享)、map_private(私有)等
fd：文件描述符，��于匿名映射设为-1
offset：映射的文件偏移量，通常为0

mmap成功时返回映射区域的起始地址，失败时返回map_failed((void*)-1)。

二、父子进程创建方式

在linux中，可以通过多种方式创建父子进程：

fork()：创建一个与父进程几乎完全相同的子进程
vfork()：创建一个与父进程共享地址空间的子进程
clone()：更灵活地创建进程，可以指定共享的资源

最常用的是fork()函数，它创建的子进程是父进程的一个副本，拥有独立的地址空间。但是，通过mmap创建的匿名映射区域可以在父子进程间共享。

三、使用mmap实现父子进程通信

下面我们通过一个示例来展示如何使用mmap实现父子进程间的通信：

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

#define shm_size 1024

int main() {
    // 使用mmap创建匿名映射
    void *shared_mem = mmap(null, shm_size, prot_read | prot_write, map_shared | map_anonymous, -1, 0);
    if (shared_mem == map_failed) {
        perror("mmap failed");
        exit(exit_failure);
    }

    pid_t pid = fork();
    
    if (pid < 0) {
        perror("fork failed");
        exit(exit_failure);
    } else if (pid == 0) {
        // 子进程代码
        printf("child process writing to shared memory\n");
        strcpy((char *)shared_mem, "hello from child process!");
        
        // 子进程结束
        exit(exit_success);
    } else {
        // 父进程代码
        // 等待子进程结束
        wait(null);
        
        printf("parent process reading from shared memory: %s\n", (char *)shared_mem);
        
        // 解除映射
        if (munmap(shared_mem, shm_size) == -1) {
            perror("munmap failed");
            exit(exit_failure);
        }
    }
    
    return 0;
}

代码解析：

首先使用mmap创建一个大小为1024字节的匿名映射区域，设置保护标志为prot_read | prot_write，表示可读可写；设置映射类型为map_shared | map_anonymous，表示这是一个共享的匿名映射。
使用fork()创建子进程。子进程会继承父进程的地址空间，包括mmap创建的共享内存区域。
在子进程中，向共享内存写入一条消息：“hello from child process!”。
父进程通过wait()等待子进程结束，然后从共享内存中读取子进程写入的消息并打印。
最后，使用munmap()解除映射，释放共享内存资源。

四、注意事项和最佳实践

同步问题：由于多个进程可以同时访问共享内存，可能会出现数据竞争问题。可以使用信号量、互斥锁等同步机制来保证数据的一致性。
内存保护：合理设置mmap的保护标志，避免不必要的读写权限，提高安全性。
错误处理：对mmap、fork等系统调用进行充分的错误检查，确保程序的健壮性。
资源释放：确保在程序结束前调用munmap释放映射的内存区域，避免内存泄漏。
大小选择：根据实际需求选择合适的共享内存大小，避免浪费或不足。

五、扩展应用

mmap不仅可以用于父子进程间通信，还可以用于：

无亲缘关系的进程间通信：通过将文件映射到内存，不同进程可以访问同一个文件实现通信。
内存映射文件：将大文件映射到内存，可以高效地访问文件内容，而不需要将整个文件读入内存。
虚拟内存管理：mmap是linux虚拟内存管理系统的重要组成部分，用于管理进程的地址空间。

六、进阶示例：带同步的父子进程通信

下面是一个更复杂的示例，展示了如何在父子进程间使用mmap和信号量进行同步通信：

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

#define shm_size 1024
#define sem_name "/my_semaphore"

typedef struct {
    char message[shm_size];
    int ready;
} shareddata;

int main() {
    // 创建或打开信号量
    sem_t *sem = sem_open(sem_name, o_creat, 0644, 0);
    if (sem == sem_failed) {
        perror("sem_open failed");
        exit(exit_failure);
    }
    
    // 使用mmap创建匿名映射
    shareddata *shared_data = mmap(null, sizeof(shareddata), prot_read | prot_write, map_shared | map_anonymous, -1, 0);
    if (shared_data == map_failed) {
        perror("mmap failed");
        exit(exit_failure);
    }
    
    pid_t pid = fork();
    
    if (pid < 0) {
        perror("fork failed");
        exit(exit_failure);
    } else if (pid == 0) {
        // 子进程代码
        printf("child process writing to shared memory\n");
        strcpy(shared_data->message, "hello from child process with synchronization!");
        shared_data->ready = 1;
        
        // 通知父数据已准备好
        if (sem_post(sem) == -1) {
            perror("sem_post failed");
            exit(exit_failure);
        }
        
        // 子进程结束
        exit(exit_success);
    } else {
        // 父进程代码
        // 等待子进程通知
        if (sem_wait(sem) == -1) {
            perror("sem_wait failed");
            exit(exit_failure);
        }
        
        printf("parent process reading from shared memory: %s\n", shared_data->message);
        
        // 解除映射
        if (munmap(shared_data, sizeof(shareddata)) == -1) {
            perror("munmap failed");
            exit(exit_failure);
        }
        
        // 关闭并删除信号量
        if (sem_close(sem) == -1) {
            perror("sem_close failed");
            exit(exit_failure);
        }
        
        if (sem_unlink(sem_name) == -1) {
            perror("sem_unlink failed");
            exit(exit_failure);
        }
    }
    
    return 0;
}

这个示例展示了如何使用信号量来同步父子进程对共享内存的访问，确保父进程在子进程写入数据后才能读取数据。