目录

一、内存映射原理

二、内存映射的操作

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

2.代码示例：

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

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

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

三、内存映射的注意事项

一、内存映射原理

内存映射 （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;
}

执行结果：

实现了 将文件 english.txt 的内容拷贝到了 cpy.txt 中。 

三、内存映射的注意事项

1.如果对mmap的返回值(ptr)做++操作(ptr++), munmap是否能够成功?

void* ptr = mmap(...);
ptr++;    可以对其进行++操作
munmap(ptr,len); //错误，地址已经偏移了 ，需要保存最初的地址，才能正确释放内存

2.如果open时O_RDONLY, mmap时prot参数指定PROT_READ | PROT_WRITE会怎样?

会产生错误，返回 MAP_FAILED.
open()函数中的权限建议和prot参数的权限保持一致

3.如果文件偏移量为1000会怎样?

偏移量应该是4*1024的整数倍，返回MAP_FAILED

4.mmap什么情况下会调用失败?

第二个参数：length = 0
第三个参数：prot只指定了写权限，会失败 ； prot PROT_READ|PROT_WRITE 第5个参数fd通过open函数时指定的O_RDONLY|O_WRONLY

5.可以open的时候O_CREAT一个新文件来创建映射区吗?

可以的，但是创建的文件的大小为0的话，不行。
可以对新文件进行扩展： lseek() , truncate()

6.mmap后关闭文件描述符，对mmap映射有没有影响？

 int  fd  =  open("xxx",);
 mmap(,,,,fd,0);
 close(fd);
 映射区还存在，创建映射区的fd被关闭，没有任何影响。

7.对ptr越界操作会怎样？

void* ptr = mmap(NULL,100,,,,,);
4K
越界操作，操作的是非法内存，会产生段错误。

简述：

内核映射进程空间，就是由进程分配好空间（属于进程独占资源）后，将用户空间虚拟地址，传递到内核，然后内核映射成内核虚拟地址直接访问，此时内核访问的物理空间是位于用户空间。这样的好处是，内核直接访问进程空间，减少copy动作。

接口：

• 接口要包含的头文件：

#include <linux/mm.h>

• 函数接口：

long get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
            unsigned long start, unsigned long nr_pages,
            int write, int force, struct page **pages,
            struct vm_area_struct **vmas);

功能：内核用来映射进程内存空间
第一个参数： tsk是进程控制块指针，这个参数几乎一直作为 current 传递。
第二个参数： 一个内存管理结构的指针, 描述被映射的地址空间. mm_struct 结构是捆绑一个进程的虚拟地址空间所有部分. 对于驱动的使用, 这个参数应当一直是current->mm。
第三个参数： start 是(页对齐的)用户空间缓冲的地址。要映射进程空间虚拟地址的起始地址。
第四个参数： nr_pages是映射进程空间的大小，单位页。
第五个参数： write是内核映射这段进程空间来读还是写，非0（一般就是1）表示用来写，当然，对于用户空间就只能是读了；为0表示用来读，此时用户空间就只能是写了。
第六个参数： force 标志告知 get_user_pages 来覆盖在给定页上的保护, 来提供要求的
权限; 驱动应当一直传递 0 在这里。
第七个参数： pages是这个函数的输出参数，映射完成后，pages是指向进程空间的页指针数组，如pages[1],下标最大是nr_pages-1。注意，内核要用pages，还需要映射成内核虚拟地址，一般用kmap(),kmap_atomic()
第八个参数： vmas也是个输出参数，vm_area_struct结构体，是linux用来管理虚拟内存的，映射完成后关于虚拟内存的信息就在这结构体里面。如果驱动不用，vmas可以是NULL。
返回值： 返回实际映射的页数，只会小于等于nr_pages。

映射：

• 映射的时候要上进程读者锁：
  进程旗标（锁/信号量），通过current->mm->mmap_sem来获得。
  如：

down_read(&current->mm->mmap_sem);
result = get_user_pages(current, current->mm, ...);
up_read(&current->mm->mmap_sem);

如果内核映射的空间，用来写，写的时候要上进程写锁,在写的时候去读，就会被阻塞：

down_write(current->mm->mmap_sem);
...
//向映射的空间写数据
//up_write(current->mm->mmap_sem);

current->mm->page_table_lock.rlock也可以用这个自旋锁实现的读者写者，具体情况考虑。

释放映射：

if (! PageReserved(page))
    SetPageDirty(page);
page_cache_release(struct page *page);

PageReserved(): 判断是否为保留页，是保留页返回非0，不是返回0。在我们一般映射的页，没经过处理，都不是保留页，返回0。
SetPageDirty(): 简单来说，就是告诉系统这页被修改。

PageReserved(),SetPageDirty()定义在include/linux/page-flags.h，对他们的作用理解，兵不是很深，在一般的驱动中可有可无，安全起见，就按照上面形式放在哪里。

page_cache_release()定义在include/linux/pagemap.h，只能是一次释放一个page，多个page用循环多次调用。

思考：

这种映射，主要是用在进程直接I/O，进程直接读写用户空间内存，就可以达到读写I/O。但是也要具体情况看，相对这种映射对系统开销，还是比较大的。
get_user_pages的用法例子，可以看drivers/scsi/st.c

用这种映射来实现读者写者，进程是读者，驱动是写者。
在“linux驱动—file_operations异步读写aio_read、aio_write”这章，描述的异步例子基础上做，

原始例子如下：

struct kiocb *aki;
struct iovec *aiov;
loff_t aio_off = 0;
struct workqueue *aiowq;

void data_a(struct work_struct *work);
DECLARE_DELAYED_WORK(aio_delaywork,data_a);

ssize_t d_read(struct file *f, char __user *buf, size_t n, loff_t *off)
{
}
void data_a(struct work_struct *work)
{
    int ret = 0;
    ret = d_read(aki->ki_filp,aiov->iov->iov_base,n,&off);
    aio_complete(aki,ret ,0);
}
ssize_t d_aio_read(struct kiocb *ki, const struct iovec *iovs, unsigned long n, loff_t off)
{
    if(is_sync_kiocb(ki))
        return d_read(ki->ki_filp,iovs->iov->iov_base,n,&off);
    else
    {
        aki = ki;
        aiov = iovs;
        aio_off = off;
        queue_delayed_work(aiowq,aio_delaywork,100);
        return -EIOCBQUEUED;//一般都返回这个，
    }
}
void init_aio()
{
    aiowq= create_workqueue("aiowq");
}

用上get_user_pages()后，将变成：

#include <linux/list.h>
#include <linux/aio.h>
#include <linux/workqueue.h>
#include <linux/mm.h>

struct kiocb *aki;
//struct iovec *aiov;
//loff_t aio_off = 0;
struct workqueue *aiowq;
struct page **aiopages;



LIST_HEAD(custom_aa);

struct custom_async{
    list_head list;
    task_struct *tsk;
    struct page **pg;
    long page_num;
    ssize_t size;   
};

void data_a(struct work_struct *work);
DECLARE_DELAYED_WORK(aio_delaywork,data_a);
DECLARE_DELAYED_WORK(aio_delaywork_c,async_d_writedata);

struct file_operations {
    .owner = THIS_MODE,
    .read = d_read,
    .aio_read = d_aio_read,
    ...
    ..
};


ssize_t d_read(struct file *f, char __user *buf, size_t n, loff_t *off)
{
}
ssize_t async_d_writedata(struct work_struct *work)
{
    int i,n;
    void *p = NULL;
    struct page **temp = NULL;
    struct custom_async *t = NULL;
    struct list_head *tmp = NULL;
    list_for_each(custom_aa,tmp){
        t = container_of(tmp,custom_async,list);
        for(i=0;i<t->page_num;i++)
        {
            temp = t->pg;
            p = kmap(temp[i]);
            down_write(&t->tsk->mm->mmap_sem);
            ...
            //向p指定的空间写数据 ,   n为写了多少个字节数据
            ...
            t->size = n;
            up_write(&t->tsk->mm->mmap_sem);
            kunmap(aio_pages[i]);
        }
    }
    queue_delayed_work(aiowq,aio_delaywork_c,100);  
}
void data_a(struct work_struct *work)
{
    int ret = 0;
    struct custom_async *t;
    //ret = d_read(aki->ki_filp,aiov->iov->iov_base,n,&off);

    t = container_of(custom_aa.next,custom_async,list);
    async_d_writedata();     
    ret = t->size;
    aio_complete(aki,ret ,0);
}
ssize_t d_aio_read(struct kiocb *ki, const struct iovec *iovs, unsigned long n, loff_t off)
{   
    if(is_sync_kiocb(ki))
        return d_read(ki->ki_filp,iovs->iov->iov_base,n,&off);
    else
    {
        aki = ki;
        //aiov = iovs;
        //aio_off = off;
        struct custom_async *p;

        p = kmalloc(sizeof(struct custom_async));
        memset(p,0,sizeof(struct custom_async));
        INIT_LIST_HEAD(&p->list);
        list_add(&p->list,&custom_aa); 
        p->tsk = current;       
        down_read(&current->mm->mmap_sem);
        pagenum = get_user_pages(current,current->mm,iovs->iov->iov_base,
                        n/PAGE_SIZE+(n%PAGE_SIZE)?1:0,
                        1,0,p->pg,NULL);
        up_read(&current->mm->mmap_sem);       
        queue_delayed_work(aiowq,aio_delaywork,100);
        return -EIOCBQUEUED;//一般都返回这个，
    }
}
void init_aio()
{
    aiowq= create_workqueue("aiowq");
    INIT_LIST_HEAD(custom_aa);
}
void exit()
{
    int i;
    ...
    ..
    for(i=0;i<pagenum;i++)
    {
        if (! PageReserved(aiopages[i]))
            SetPageDirty(aiopages[i]);
        page_cache_release(aiopages[i]);
    }
    ...
    ..
}

上面的例子，进程都可以通过异步调用来申请映射，当进程收到一次异步调用完成后，不用再次异步调用，只需要读就可以，驱动会自动的向里面写数据。只要来异步调用申请过一次的进程，当有数据时,都会向每个进程空间写数据。典型的读者写者，进程是读者，驱动是写者。

上面例子，只是表达了处理逻辑，没有编译过，模块退出时，释放不完全。

对比一般的异步，内核是直接向进程空间写数据，不用在数据完成后，还需要一次copy，理论上会快些。

目录

一.程序地址空间

二.进程地址空间

---

一.程序地址空间

首先我们先通过一张图回顾一下c/c++中的程序地址空间：

 下面简单的介绍一个这几个区域：

1.堆区：

堆数据区即heap区，在C程序中，该区域的分配和回收由malloc和free进行。随着区域分配的进行，区域不断从低地址向高地址方向延伸。

2.栈区：

stack区，程序运行时，函数调用产生的堆栈存放在该区域。该区域的开始地址是固定的（紧挨着内核内存区），随着调用函数时堆栈的产生，该区域不断从高地址向低地址方向延伸.

3.代码与数据区:

可执行程序文件的内容加载到该区域，该区域又分成2部分，低地址部分包含程序的代码及只读数据，为只读部分;另一区域存放可执行文件的可读写数据，为可读写区。

4.内核存储区：

内核虚拟内存区，在虚拟地址空间的最高地址处的一块地址空间内。该区域用户进程不能访问。

题目通过一段简单的代表对上图的地址空间分部进行验证：

#include<stdio.h>                                                                                                                                           
  2 #include<iostream>
  3 using namespace std;
  4   int g_unval;
  5  int g_val=0;
  6  int main()
  7  {
  8    printf("code addr:%p\n",main);//打印代码区的地址
  9    const char*str="ddddddd";
 10    printf("string rdonly addr %p\n",str);//打印字符常量区的地址
 11    //打印未初始化全局数据区的地址
 12    printf("uninit addr: %p\n",&g_unval);
 13    //打印已初始化全局数据区
 14    printf("init addr: %p\n",&g_val);
 15   //打印堆区的地址 
 16      int *p1=new int (1);
 17      int *p2=new int(2);
 18      int *p3=new int(3);
 19     printf("heap addr: %p \n",p1);
 20     printf("heap addr: %p \n",p2);
 21     printf("heap addr: %p \n",p3);
 22 
 23 
 24    //打印栈区的地址
 25    int a1=10;
 26    int a2=20;
 27    int a3=30;
 28    printf("stack addr : %p\n",&a1);
 29    printf("stack addr : %p\n",&a2);
 30    printf("stack addr : %p\n",&a3);
 31 
 32    return 0;
 33 }
~

允许结果：

 我么发现分部确实是这样的。

下面我们来做一个实验：

#include<unistd.h>
  2 #include<stdio.h>
  3 #include<sys/types.h>
  4 int g_val=10;
  5 int main()
  6 {
  7   pid_t id=fork();
  8   if(id<0)
  9   {
 10     printf("fork fail");
 11   }
 12   else if(id==0)
 13   {
 14    while(1)
 15    {
 16     printf(" I am a child pid:%d  g_val:%d &g_val:%p\n",getpid(),g_val,&g_val);
 17     sleep(2);
 18    }
 19 
 20   }
 21   else
 22   {
 23     while(1)
 24     {
 25       printf("I am a parent pid:%d  g_val :%d &g_val:%p\n",getpid(),g_val,&g_val);                                                                          
 26       sleep(2);
 27     }
 28 
 29   }
 30 
 31   return 0;
 32 }
 33 

我们将这个代码跑起来：

 子进程和父进程的打印出来的g_val和&g_val是一样的没有问题这和我们之前说的父子进程在代码和数据是共享的（不发生修改的前提下).没有问题，下面我们再来看一段代码：

#include<unistd.h>
  2 #include<stdio.h>
  3 #include<sys/types.h>
  4 int g_val=100;                                                                                                                                              
  5 int main()
  6 {
  7   pid_t id=fork();
  8   if(id<0)
  9   {
 10     printf("fork fail");
 11   }
 12   else if(id==0)
 13   {
 14     int cnt=0;
 15    while(1)
 16    {
 17      cnt++;
 18      if(cnt==3)
 19      {
 20        g_val=10;
 21        printf("子进程修改g_val\n");
 22      }
 23     printf(" I am a child pid:%d  g_val:%d &g_val:%p\n",getpid(),g_val,&g_val);
 24     sleep(2);
 25    }
 26 
 27   }
 28   else
 29   {
 30     while(1)
 31     {
 32       printf("I am a parent pid:%d  g_val :%d &g_val:%p\n",getpid(),g_val,&g_val);
 33       sleep(2);
 34     }
 35 
 36   }
 37 
 38   return 0;
 39 }
 40 
                                                                              
                                              

我们将这个程序跑起来：

 我们发现子进程把g_val的值修改之后由于进程之间是独立的发生了写时拷贝，子进程和父进程打印出来的值不一样我们可以理解但是我们惊奇的发现他们的地址是一样的。如果这里是物理地址，怎么可能从同一块空间里面取里面的内容还不相同。所以我们可以得出：

这绝对不是物理地址。在Linux地址下，这种地址叫做虚拟地址，我们在用C/C++语言所看到的地址，全部都是虚拟地址！物理地址，用户一概看不到，由OS统一管理。

二.进程地址空间

所以我们之前说‘程序的地址空间’是不准确的，准确的应该说成进程地址空间。进程地址空间是OS创建的一个结构题名字叫做mm_struct对虚拟地址空间进行划分其虚拟地址从（0x 00 00 00 00到 oxff ff ff ff)同样的别进程控制块PCB管理起来，每个进程对有自己的进程地址空间，也就是每个进程都认为自己是独占资源认为自己拥有4GB的空间（32位平台下）。所以说进程地址空间其实是一个虚拟地址空间。虚拟地址空间也可以认为是地址空间上进行区域划分时，对应的线性位置虚拟地址!。

虚拟地址空间每个进程都有虚拟地址空间，OS会将虚拟地址通过某种映射关系映射到物理地址上，从而对应到真正的物理地址上。

 而这个做转换工作的就是传说之中的页表。下面我们就可以解释上面那种现象了，子进程的创建以父进程为模板，所以父子进程都有虚拟地址空间，且内容基本是一样的（部分数据不一样），且页表的映射关系子进程和父进程是一样的当子进程对数据进行修改时，OS会将子进程中断重新开辟一块空间将数据拷贝过来，然后让子进程修改新开辟的空间。虽然物理地址发生了改变但是虚拟地址没有发生变化，这是改变了子进程中虚拟地址和物理地址的映射关系。所以我们之前看到的地址相同本质时虚拟地址相同。

 现在我们也就能够明白父子进程是如何做到独立的了。父子进程代码和数据共享，但是只要有一方尝试对其进行写入，那么也就会方式写时拷贝，修改页表中的映射到物理内存的关系，从而使得父子进程有属于自己的数据，达到独立

为什么要这么设计呢？

理由一：

有了虚拟地址空间，让进程访问物理内存不能直接访问物理内存，添加了一个中间层（页表），更利于管理内存的操作。这样一来每个进程就必须要通过虚拟地址空间和页表来访问对应的物理内存，在将虚拟地址转换为物理地址时操作系统可以进行插手，判断转换之后是不是合法的物理地址，从而保护了物理内存。

理由二：

将内存申请和内存使用的概念在时间上划分清楚，通过虚拟地址空间屏蔽底层申请的一系列操作，从而让OS更好的管理内存和进程。

理由三：

有了虚拟地址空间，每个进程认为自己独占内存资源，以相同的方式看待内存。这样就大大的提高了OS的管理效率

举个例子：CPU在执行代码时，首先要找到程序开始的位置即起始地址，有了虚拟地址空间就只需要查找固定的虚拟地址，不同的进程的进程地址空间有着不同的映射关系，所以这个固定的虚拟地址在不同的进程中会映射到不同的物理地址，查找进程相关的代码和数据，让CPU很快的就能过查找到程序的开始位置。

理由四：

虚拟地址空间可以让地址连续化，降低异常访问及越界的概率。

重新理解进程和进程的创建：

1.什么是进程？进程是被加载到内存中的程序，包括了代码，数据以及OS为之创建的数据结构（PCB（task_struct)+mm_struct(进程地址空间）+页表。而我们通过PCB能够找到对应的mm_struct.