Linux 进程间通信之内存映射 [Linux高并发服务器开发]

Monkey Ji

已于 2022-01-21 01:04:33 修改

阅读量1.3k

点赞数 3

分类专栏： Linux高并发服务器开发文章标签：服务器 linux 后端 unix c语言

于 2022-01-21 00:50:32 首次发布

本文链接：https://blog.csdn.net/Appleeatingboy/article/details/122421467

版权

Linux高并发服务器开发专栏收录该内容

15 篇文章 9 订阅

订阅专栏

一、内存映射原理

内存映射（Memory-mapped I/O）是 将磁盘文件的数据映射到内存，用户通过修改内存从而修改磁盘文件。对内存直接操作，因此效率比较高。

根据示意图，将文件的数据映射到虚拟地址空间，进程的虚拟地址空间最终会对应实际的内存。会映射到共享库，加载的内存区域。

可以只映射文件中的一部分数据。修改内存中的数据，操作系统会将内存中的数据同步到文件中，从而通过修改内存数据，实现了修改文件中的数据。

另外的进程，可以通过读取文件的数据，读取到数据。通过这种方式，可以实现进程间通信。实际的效率相对较高，因为是对内存的操作。

二、内存映射的操作

1.内存映射相关的系统调用：

#include <sys/mman.h>

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

-功能：将一个文件或者设备的数据映射到内存中

-参数：

-void* addr: NULL, 由内核指定

-length:要映射的数据的长度，这个值不能为0。建议使用文件的长度。

获取文件的长度：stat lseek

如果分配的长度没有达到内存分页的长度，会按照内存分页的长度进行创建。

-prot:对申请的内存映射区的操作权限

同时拥有读写的权限：PROT_READ | PROT_WRITE

PROT_EXEC Pages may be executed.

PROT_READ Pages may be read.

PROT_WRITE Pages may be written.

PROT_NONE Pages may not be accessed.

要操作映射区内存，必须要有读的权限：

PROT_READ 或 PROT_READ | PROT_WRITE

-flags:

MAP_SHARED: Share this mapping.

映射区的数据会自动和磁盘文件进行同步，进程间通信，必须要设置这个选项。

MAP_PRIVATE: Create a private copy-on-write mapping.

不同步，内存映射区的数据改变了，对原来的文件不会修改，底层会重新创建一个新的文件(copy-on-write)

-fd:需要映射的那个文件的文件描述符

通过open得到，open的是一个磁盘文件

注意：文件的大小不能为0， open指定的权限不能和prot参数有冲突。

prot:PROT_READ open：只读或读写

prot:PROT_READ | PROT_WRITE open：读写

-offset:偏移量，一般不用，必须指定的是 4K 的整数倍。 0表示不偏移

- 返回值：

成功，返回映射的地址。On success, mmap() returns a pointer to the mapped area.

失败，On error, the value MAP_FAILED (that is, (void *) -1) is returned.

int munmap(void *addr, size_t length);

- 功能：释放内存映射

- 参数：

-addr:要释放的内存的首地址

-length:要释放的内存的大小，要和mmap函数中的length参数的值一样

-返回值：

成功，返回 0

失败，返回 -1

使用内存映射实现进程间通信

1.有关系的进程（父子进程）

- 还没有子进程的时候：

通过唯一的父进程，先创建内存映射区，有了内存映射区以后，创建子进程，父子进程共享创建的内存映射区

2.没有关系的进程间通信：

-准备一个大小不是0的磁盘文件

进程1通过磁盘文件创建内存映射区，得到一个操作这块内存的指针

进程2通过对同一个磁盘文件创建内存映射区，得到一个操作这块内存的指针

使用内存映射区通信

注意：内存映射区通信，是非阻塞的。

2.代码示例：

注意：

如下两个示例的程序，都需要先创建一个 test.txt文件，并且在文件中，随便填充一些字符。

2.1 有关系的进程 - 父子进程

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


int main()
{
    //1.打开一个文件
    int fd = open("test.txt",O_RDWR);
    int size = lseek(fd,0,SEEK_END);

    //2.创建内存映射区
    void* ptr = mmap(NULL,size,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    if(ptr == MAP_FAILED)
    {
        perror("mmap");
        exit(0);
    }

    //3.创建子进程
    pid_t  pid = fork();

    if(pid>0)
    {
        //回收子进程的资源
        wait(NULL);
        //父进程
        char buf[64];
        strcpy(buf,(char*)ptr);
        printf("read data:%s\n",buf);
    }
    else if(pid == 0)
    {//子进程
        strcpy((char*)ptr, "my son,dear!");

    }

    return 0;
}

执行结果：

2.2 独立的没有关系的进程通信

process1

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


int main()
{
    //1.打开一个文件
    int fd = open("test.txt",O_RDWR);
    int size = lseek(fd,0,SEEK_END);

    //2.创建内存映射区
    void* ptr = mmap(NULL,size,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    if(ptr == MAP_FAILED)
    {
        perror("mmap");
        exit(0);
    }
    
    //读数据
    char buf[64];
    strcpy(buf,(char*)ptr);
    printf("read data:%s\n",buf);

    return 0;
}

process2

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


int main()
{
    //1.打开一个文件
    int fd = open("test.txt",O_RDWR);
    int size = lseek(fd,0,SEEK_END);

    //2.创建内存映射区
    void* ptr = mmap(NULL,size,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    if(ptr == MAP_FAILED)
    {
        perror("mmap");
        exit(0);
    }

    //写数据
    strcpy((char*)ptr, "my son well,dear!");

    return 0;
}

执行结果：

3.使用内存映射实现文件拷贝

思路：
1.对原始的文件进行内存映射
2.创建一个新文件（拓展该文件）
3.把新文件的数据映射到内存中
4.通过内存拷贝将第一个文件的内存数据拷贝到新的文件内存中
5.释放资源

功能：将 englis.txt 中的内容拷贝到 cpy.txt 文件中

代码如下：

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

int main() {

    // 1.对原始的文件进行内存映射
    int fd = open("english.txt", O_RDWR);
    if(fd == -1) {
        perror("open");
        exit(0);
    }

    // 获取原始文件的大小
    int len = lseek(fd, 0, SEEK_END);

    // 2.创建一个新文件（拓展该文件）
    int fd1 = open("cpy.txt", O_RDWR | O_CREAT, 0664);
    if(fd1 == -1) {
        perror("open");
        exit(0);
    }
    
    // 对新创建的文件进行拓展
    truncate("cpy.txt", len);
    write(fd1, " ", 1);

    // 3.分别做内存映射
    void * ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    void * ptr1 = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd1, 0);

    if(ptr == MAP_FAILED) {
        perror("mmap");
        exit(0);
    }

    if(ptr1 == MAP_FAILED) {
        perror("mmap");
        exit(0);
    }

    // 内存拷贝
    memcpy(ptr1, ptr, len);
    
    // 释放资源
    munmap(ptr1, len);
    munmap(ptr, len);

    close(fd1);
    close(fd);

    return 0;
}

执行结果：