【Linux】Linux系统编程(入门与系统编程)（三）(深入理解操作系统、进程、环境变量、内存分布）

本博客操作系统最多涉及30%的理论，重点在于部分进程的内容，部分文件系统的内容，部分文件管理的内容不是主讲操作系统，我们的最终目的是理解系统中最高频的知识点，然后被完全利用指导我们编程。

        下面是这三篇博客的系统的思维导图

本节重点：
认识冯诺依曼系统
操作系统概念与定位
深入理解进程概念，了解PCB
学习进程状态学会创建进程，掌握僵尸进程和孤儿进程，及其形成原因和危害
了解进程调度，Linux进程优先级，理解进程竞争性与独立性，理解并行与并发
理解环境变量，熟悉常见环境变量及相关指令, getenv/setenv函数
理解C内存空间分配规律，了解进程内存映像和应用程序区别, 认识地址空间。
冯诺依曼体系结构
        我们常见的计算机，如笔记本。我们不常见的计算机，如服务器，大部分都遵守冯诺依曼体系。

        截至目前，我们所认识的计算机，都是有一个个的硬件组件组成 

 输入单元：包括键盘, 鼠标，扫描仪, 写板等
中央处理器(CPU)：含有运算器和控制器等
输出单元：显示器，打印机等
        关于冯诺依曼，必须强调几点： 

这里的存储器指的是内存。
不考虑缓存情况，这里的CPU能且只能对内存进行读写，不能访问外设(输入或输出设备)。
外设(输入或输出设备)要输入或者输出数据，也只能写入内存或者从内存中读取。
一句话，所有设备都只能直接和内存打交道。
        对冯诺依曼的理解，不能停留在概念上，要深入到对软件数据流理解上 ！

操作系统(Operating System) 
操作系统给用户提供一个稳定，安全简单的执行环境！

概念
        任何计算机系统都包含一个基本的程序集合，称为操作系统(OS)。笼统的理解，操作系统包括：

内核（进程管理，内存管理，文件管理，驱动管理）
其他程序（例如函数库，shell程序等等）
设计OS的目的 
与硬件交互，管理所有的软硬件资源
为用户程序（应用程序）提供一个良好的执行环境
定位 
在整个计算机软硬件架构中，操作系统的定位是：一款纯正的“搞管理”的软件

总结
计算机管理硬件

描述起来，用struct结构体
组织起来，用链表或其他高效的数据结构 
系统调用和库函数概念 
在开发角度，操作系统对外会表现为一个整体，但是会暴露自己的部分接口，供上层开发使用，这部分由操作系统提供的接口，叫做系统调用。
系统调用在使用上，功能比较基础，对用户的要求相对也比较高，所以，有心的开发者可以对部分系统 调用进行适度封装，从而形成库，有了库，就很有利于更上层用户或者开发者进行二次开发。
        操作系统通过先描述后组织管理系统！

进程
        我们启动一个软件，就是启动一个进程！

        在Linux中，运行一条命令, ./XXX,运行的时候，其实就是在系统层面创建了一个进程！

        Linux系统是可以同时加载多个程序，Linux同时存在大量的进程在系统中的，先描述再组织！

        可执行程序也是文件！

        等大家了解以后就会明白，对进程的管理，实际上就是对PCB结构体链表的增删改查！

基本概念 
什么叫进程？
        进程 = 对应的代码和数据 + 描述进程的PCB结构。

课本概念：程序的一个执行实例，正在执行的程序等
内核观点：担当分配系统资源（CPU时间，内存）的实体。
描述进程-PCB
进程信息被放在一个叫做进程控制块的数据结构中，可以理解为进程属性的集合。
课本上称之为PCB（process control block），Linux操作系统下的PCB是: task_struct{} 是一个结构体
task_struct-PCB的一种 
在Linux中描述进程的结构体叫做task_struct。
task_struct是Linux内核的一种数据结构，它会被装载到RAM(内存)里并且包含着进程的属性信息。
task_ struct内容分类
标示符: 描述本进程的唯一标示符，用来区别其他进程。
状态: 任务状态，退出代码，退出信号等。
优先级: 相对于其他进程的优先级。
程序计数器: 程序中即将被执行的下一条指令的地址。
内存指针: 包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块的指针
上下文数据: 进程执行时处理器的寄存器中的数据[休学例子，要加图CPU，寄存器]。
I／O状态信息: 包括显示的I/O请求,分配给进程的I／O设备和被进程使用的文件列表。
记账信息: 可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号等。
其他信息
组织进程 
        可以在内核源代码里找到它。所有运行在系统里的进程都以task_struct链表的形式存在内核里。 

查看进程
        下面是一段c语言代码，大家可以执行一下！

#include <stdio.h>
#include <unistd.h>
int main()
        {
                while(1)
                {
                        printf("Hello world");
                        sleep(1);
                }
                return 0;
        }
        查看当前的进程 ！

ps只可以查看当前从终端的进程

ps axj

        可以查看系统所有进程！

进程的信息可以通过 /proc 系统文件夹查看

        如：要获取PID为1的进程信息，你需要查看 /proc/1 这个文件夹。
        利用管道查看系统proc进程
        

大多数进程信息同样可以使用top和ps这些用户级工具来获取

ps axj | grep 'myproc'

ps axj | head -1 && ps axj | grep 'myproc' 

        把头部带上！

         PID就是进程ID！

        如图第二条命令其实是我们命令这个程序的进程 ！

        top也可查看进程，相当于windows任务管理器！

系统中存在一个内存级文件系统，把内存级进程以文件系统的形式展现出来！

         根据进程ID进入对应的文件夹查看，也就是上面蓝色的，里面有这个进程的所有属性！

 

 

 

杀进程的两种方法
1、ctrl+c

2、kill -9 +PID

获取当前进程的PID
#include<sys/types.h>

 pid_t id =getpid()

我们的第一个系统调用！

 获取父进程PID
 pid_t id =getppid();

 

       然后，我发现我把终端杀了 ！

        然后我发现父进程是这个家伙，就是bash！

        最后我了解到了，每次登陆都有新的bash！

通过系统调用创建进程-fork初识
运行 man fork 认识fork
fork有两个返回值
父子进程代码共享，数据各自开辟空间，私有一份（采用写时拷贝）
        pid_t fork()

        返回值：！

        创建一个子进程！

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
 int ret = fork();
 printf("hello proc : %d!, ret: %d\n", getpid(), ret);
 sleep(1);
 return 0;
}
        fork 之后通常要用 if 进行分流
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
 int ret = fork();
 if(ret < 0){
 perror("fork");
 return 1;
 }
 else if(ret == 0){ //child
 printf("I am child : %d!, ret: %d\n", getpid(), ret);
 }else{ //father
 printf("I am father : %d!, ret: %d\n", getpid(), ret);
 }
 sleep(1);
 return 0;
}

        成功时返回子进程0值！

        给父进程返回子进程的PID！

        id在父进程里边子进程的PID！

         fork之后代码是父子共享的！

        perror("fork");
        这句代码可以通过c语言，答应出代码失败的原因！

#include<stdio.h>
#include<unistd.h>
 
int main()
{
 
        pid_t id = fork();
        if(id < 0){
                printf("创建失败");
                perror("fork");
                return 1;
        }
        else if(id==0){
        //子进程
                while(1){
                        printf("I am child, pid: %d,ppid:%d\n",getpid(),getppid());
                        sleep(1);
                }
        }
        else{
                 while(1){
                        printf("I am father, pid: %d,ppid:%d\n",getpid(),getppid());
                        sleep(1);
                }
 
        //父进程
        }
//      printf("you can see me!\n");
//      sleep(1);
        return 0;
}
 
~               

        这样可以达到分离父子进程代码的作用  ！

        fork后有俩个不同的执行流！

 

 while :; do ps axj | head -1 && ps ajx | grep myproc| grep -v grep;sleep 1;  done

        这是一个方便大家监控进程的脚步命令

操作系统和cpu运行某一个进程，本质从task_struct形成的队列中选择一个task_struct，来执行它的代码！

进程调度，变成了在task_struct的队列中选择一个进程的过程。

当我们准备return时，我们的核心代码已经完成！

为什么会有两个fork返回值？

        应为fork内部，父子各自会执行自己的return语句！

        返回两次不意味会保存两次！

父子进程，哪一个进程会先被运行？

        不一定！，看操作系统调度器的算法有关！

进程状态
看看Linux内核源代码怎么说
        为了弄明白正在运行的进程是什么意思，我们需要知道进程的不同状态。一个进程可以有几个状态（在 Linux内核里，进程有时候也叫做任务）。

下面的状态在kernel源代码里定义：

/*
* The task state array is a strange "bitmap" of
* reasons to sleep. Thus "running" is zero, and
* you can test for combinations of others with
* simple bit tests.
*/
static const char * const task_state_array[] = {
"R (running)", /* 0 */
"S (sleeping)", /* 1 */
"D (disk sleep)", /* 2 */
"T (stopped)", /* 4 */
"t (tracing stop)", /* 8 */
"X (dead)", /* 16 */
"Z (zombie)", /* 32 */
};

R运行状态（running）: 并不意味着进程一定在运行中，它表明进程要么是在运行中要么在运行队列 里。
S睡眠状态（sleeping): 意味着进程在等待事件完成（这里的睡眠有时候也叫做可中断睡眠 （interruptible sleep））。 
D磁盘休眠状态（Disk sleep）有时候也叫不可中断睡眠状态（uninterruptible sleep），在这个状态的 进程通常会等待IO的结束。
T停止状态（stopped）： 可以通过发送 SIGSTOP 信号给进程来停止（T）进程。这个被暂停的进程可 以通过发送 SIGCONT 信号让进程继续运行。
X死亡状态（dead）：这个状态只是一个返回状态，你不会在任务列表里看到这个状态。

Linux操作系统进程的状态

新建
运行：task_struct结构体在运行队列中排队（等待cpu的资源），就叫做运行状态
阻塞：系统中，我们一定是存在各种资源的，不一定是cpu，这种情况在等待其他资源！等待非cpu资源就绪就是阻塞状态！
挂起：当内存不足，操作系统通过适当的置换进程的代码和数据到磁盘。
进程状态查看 
ps aux / ps axj 命令

        带加号意味着属于前台任务 !

        后台运行，也就是休眠状态，等待时间完成!

         r对应的是上面的运行态

        s对应的就是上面的阻塞状态，可中断睡眠

        d睡眠状态，磁盘睡眠，深度睡眠，不可中断睡眠，不可以被动唤醒！当服务器压力过大，操作系统会杀死一些进程，起到节省空间的作用！D是操作系统不杀的

        T暂停调试

        x终止瞬时性很难捕捉到

        Z僵尸状态（一个进程以及死亡，但还不允许被操作系统释放，处于一个检测的状态，一般是父进程和操作系统来检测，维持该状态为了父进程和操作系统回收）

将进程睡眠
命令：kill -19 PID

 

                                                                                                                                                                                                        失效的 

僵尸进程危害 
僵死状态（Zombies）是一个比较特殊的状态。当进程退出并且父进程（使用wait()系统调用,后面讲） 没有读取到子进程退出的返回代码时就会产生僵死(尸)进程
僵死进程会以终止状态保持在进程表中，并且会一直在等待父进程读取退出状态代码。
所以，只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入Z状态
来一个创建维持30秒的僵死进程例子：

#include <stdio.h>
#include <stdlib.h>
int main()
{
 pid_t id = fork();
 if(id < 0){
 perror("fork");
 return 1;
 }
 else if(id > 0){ //parent
 printf("parent[%d] is sleeping...\n", getpid());
 sleep(30);
 }else{
 printf("child[%d] is begin Z...\n", getpid());
 sleep(5);
 exit(EXIT_SUCCESS);
 }
 return 0;
}

        编译并在另一个终端下启动监控

        开始测试 

 

        看到结果

 ptrace系统调用追踪进程运行，有兴趣研究一下

进程的退出状态必须被维持下去，因为他要告诉关心它的进程（父进程），你交给我的任务，我办的怎 么样了。可父进程如果一直不读取，那子进程就一直处于Z状态？是的！
维护退出状态本身就是要用数据维护，也属于进程基本信息，所以保存在task_struct(PCB)中，换句话 说，Z状态一直不退出，PCB一直都要维护？是的！
那一个父进程创建了很多子进程，就是不回收，是不是就会造成内存资源的浪费？是的！因为数据结构 对象本身就要占用内存，想想C中定义一个结构体变量（对象），是要在内存的某个位置进行开辟空 间！
内存泄漏?是的！
孤儿进程
父进程如果提前退出，那么子进程后退出，进入Z之后，那该如何处理呢？
父进程先退出，子进程就称之为“孤儿进程”
孤儿进程被1号init进程领养，当然要有init进程回收喽。
 来段代码：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
 pid_t id = fork();
 if(id < 0){
 perror("fork");
 return 1;
 }
 else if(id == 0){//child
 printf("I am child, pid : %d\n", getpid());
 sleep(10);
 }else{//parent
 printf("I am parent, pid: %d\n", getpid());
 sleep(3);
 exit(0);
 }
 return 0;
}

        父进程退出，子进程还在，子进程就叫做孤儿进程！，孤儿进程会被领养，被一号进程领养（init，系统本身）

为什么要被领养？

        未来子进程退出的时候，父进程早已不在，需要领养进程来回收 ！

进程优先级
为什么要有优先级？

        就是因为cpu是有限的！

        进程太多，需要通过某种方式竞争资源！

什么是优先级？

        确认是谁应该先获得某种资源，谁后获得某种资源，我们可以用一些数据表明优先级

基本概念
cpu资源分配的先后顺序，就是指进程的优先权（priority）。
优先权高的进程有优先执行权利。配置进程优先权对多任务环境的linux很有用，可以改善系统性能。
还可以把进程运行到指定的CPU上，这样一来，把不重要的进程安排到某个CPU，可以大大改善系统整体性能。
查看系统进程
在linux或者unix系统中，用ps –l命令则会类似输出以下几个内容：

我们很容易注意到其中的几个重要信息，有下：

UID : 代表执行者的身份
PID : 代表这个进程的代号
PPID ：代表这个进程是由哪个进程发展衍生而来的，亦即父进程的代号
PRI ：代表这个进程可被执行的优先级，其值越小越早被执行
NI ：代表这个进程的nice值 
PRI and NI 
 PRI也还是比较好理解的，即进程的优先级，或者通俗点说就是程序被CPU执行的先后顺序，此值越小 进程的优先级别越高
那NI呢?就是我们所要说的nice值了，其表示进程可被执行的优先级的修正数值
PRI值越小越快被执行，那么加入nice值后，将会使得PRI变为：PRI(new)=PRI(old)+nice
这样，当nice值为负值的时候，那么该程序将会优先级值将变小，即其优先级会变高，则其越快被执行
所以，调整进程优先级，在Linux下，就是调整进程nice值
nice其取值范围是-20至19，一共40个级别。
PRI vs NI 
        需要强调一点的是，进程的nice值不是进程的优先级，他们不是一个概念，但是进程nice值会影响到进 程的优先级变化。 可以理解nice值是进程优先级的修正修正数据!

Linux具体的优先级做法
优先级=老的优先级+nice值（这个老优先级是进程每次开始的优先级）

查看我当前登录的这个会话的进程

尽所有的进程以列表的形式显示出来

        把头部带上

        pri：优先级，越小越早 

查看进程优先级的命令
用top命令更改已存在进程的nice：
top
进入top后按“r”–>输入进程PID–>输入nice值
其他概念 
竞争性: 系统进程数目众多，而CPU资源只有少量，甚至1个，所以进程之间是具有竞争属性的。为了高 效完成任务，更合理竞争相关资源，便具有了优先级
独立性: 多进程运行，需要独享各种资源，多进程运行期间互不干扰
并行: 多个进程在多个CPU下分别，同时进行运行，这称之为并行
并发: 多个进程在一个CPU下采用进程切换的方式，在一段时间之内，让多个进程都得以推进，称之为 并发
环境变量 
基本概念
环境变量(environment variables)一般是指在操作系统中用来指定操作系统运行环境的一些参数
如：我们在编写C/C++代码的时候，在链接的时候，从来不知道我们的所链接的动态静态库在哪里，但 是照样可以链接成功，生成可执行程序，原因就是有相关环境变量帮助编译器进行查找。
环境变量通常具有某些特殊用途，还有在系统当中通常具有全局特性
常见环境变量
PATH : 指定命令的搜索路径
HOME : 指定用户的主工作目录(即用户登陆到Linux系统中时,默认的目录)
SHELL : 当前Shell,它的值通常是/bin/bash。 
查看环境变量方法 
        echo $NAME //NAME:你的环境变量名称

测试PATH
        1. 创建hello.c文件

#include <stdio.h>
int main()
{
 printf("hello world!\n");
 return 0;
}
        2. 对比./hello执行和之间hello执行

        3. 为什么有些指令可以直接执行，不需要带路径，而我们的二进制程序需要带路径才能执行？

        4. 将我们的程序所在路径加入环境变量PATH当中, export PATH=$PATH:hello程序所在路径

        5. 对比测试

        6. 还有什么方法可以不用带路径，直接就可以运行呢？ 

        我们发现，系统命令可以直接执行，但我们自己的程序必须带路径！如果我们的程序所环境变量维护的也在路径中，我们的程序也能像系统命令一样执行！

        不建议把自己的命令放进去，污染命令池的！

         这样可以把自己的路径加到环境变量上去！$PATH表示原来的环境变量 ’：‘是分隔符！

测试HOME
        用root和普通用户，分别执行 echo $HOME ,对比差异 . 执行 cd ~; pwd ,对应 ~ 和 HOME 的关系

和环境变量相关的命令
1. echo: 显示某个环境变量值

2. export: 设置一个新的环境变量

3. env: 显示所有环境变量

4. unset: 清除环境变量

5. set: 显示本地定义的shell变量和环境变量

env可以看系统所有的环境变量

        main函数可以带三个参数，main(int argc,char *argv[],char *env[]) 

         *env环境变量参数

        环境变量一般是从父进程那里继承来的，最终一般是从bash继承来的

        子进程的环境变量是从父进程来的

        默认，所有的环境变量，都会被子进程继承！’

        环境变量具有全局属性！

环境变量的组织方式

 每个程序都会收到一张环境表，环境表是一个字符指针数组，每个指针指向一个以’\0’结尾的环境字符串

 通过代码如何获取环境变量
命令行第三个参数
#include <stdio.h>
int main(int argc, char *argv[], char *env[])
{
 int i = 0;
 for(; env[i]; i++){
 printf("%s\n", env[i]);
 }
 return 0;
}
通过第三方变量environ获取 
         

#include <stdio.h>
int main(int argc, char *argv[])
{
 extern char **environ;
 int i = 0;
 for(; environ[i]; i++){
 printf("%s\n", environ[i]);
 }
 return 0;
}
        libc中定义的全局变量environ指向环境变量表,environ没有包含在任何头文件中,所以在使用时 要用extern声明。 

通过系统调用获取或设置环境变量
#include <stdio.h>
#include <stdlib.h>
int main()
{
 printf("%s\n", getenv("PATH"));
 return 0;
}
常用getenv和putenv函数来访问特定的环境变量。

环境变量通常是具有全局属性的 
环境变量通常具有全局属性，可以被子进程继承下去
#include <stdio.h>
#include <stdlib.h>
int main()
{
 char * env = getenv("MYENV");
 if(env){
 printf("%s\n", env);
 }
 return 0;
}
直接查看，发现没有结果，说明该环境变量根本不存在

导出环境变量 export MYENV="hello world"
再次运行程序，发现结果有了！说明：环境变量是可以被子进程继承下去的！ 
程序地址空间
研究背景
32位平台
程序地址空间回顾 

        上面的操作完全可以看出程序地址空间的真实存在！

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
int g_val = 100;
int g_unval;
int main(int argc, char *argv[], char *env[])
{
        printf("code addr: %p\n",main);
        printf("init global addr：%p\n",&g_val);
        printf("init global addr：%p\n",&g_unval);
        char *heap_mem = (char*)malloc(10);
        printf("heap addr:%p\n",heap_mem);
        printf("stack addr:%p\n",&heap_mem);
        for(int i = 0; env[i] ; i++)
        {
                printf("argv[%d]:%p\n",i,argv[i]);
        }
        for(int i = 0;env[i];i++)
        {
                printf("env[%d]:%p\n",i,env[i]);
        }
        return 0;
}

static修饰局部变量的本质：将该变量开辟在全局区域

        来段代码感受一下

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int g_val = 0;
int main()
{
 pid_t id = fork();
 if(id < 0){
 perror("fork");
 return 0;
 }
 else if(id == 0){ //child
 printf("child[%d]: %d : %p\n", getpid(), g_val, &g_val);
 }else{ //parent
 printf("parent[%d]: %d : %p\n", getpid(), g_val, &g_val);
 }
 sleep(1);
 return 0;
}

        输出

//与环境相关，观察现象即可

parent[2995]: 0 : 0x80497d8

child[2996]: 0 : 0x80497d8 

        我们发现，输出出来的变量值和地址是一模一样的，很好理解呀，因为子进程按照父进程为模版，父子并没有对变 量进行进行任何修改。可是将代码稍加改动：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int g_val = 0;
int main()
{
 pid_t id = fork();
 if(id < 0){
 perror("fork");
 return 0;
 }
 else if(id == 0){ //child,子进程肯定先跑完，也就是子进程先修改，完成之后，父进程再读取
 g_val=100;
 printf("child[%d]: %d : %p\n", getpid(), g_val, &g_val);
 }else{ //parent
 sleep(3);
 printf("parent[%d]: %d : %p\n", getpid(), g_val, &g_val);
 }
 sleep(1);
 return 0;
}

         输出结果：

//与环境相关，观察现象即可

child[3046]: 100 : 0x80497e8

parent[3045]: 0 : 0x80497e8

        我们发现，父子进程，输出地址是一致的，但是变量内容不一样！能得出如下结论:

变量内容不一样,所以父子进程输出的变量绝对不是同一个变量

但地址值是一样的，说明，该地址绝对不是物理地址！

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

OS必须负责将 虚拟地址 转化成 物理地址

#include<stdio.h>
#include<unistd.h>
int g_val = 100;
int main()
{
        pid_t id =fork();
        if(id == 0)
        {
                int cnt =0;
                while(1)
                {
                        printf("I am child,pid:%d,ppid:%d,g_val:%d,&g_val:%p\n",\
                                        getpid(),getppid(),g_val,&g_val);
                        cnt++;
                        sleep(1);
                        if(cnt == 5)
                        {
                                g_val = 200;
                                printf("child chage g_val 100-> 200 success\n");
                        }
                }
        }
        else{
                 while(1)
                {
                        printf("I am father,pid:%d,ppid:%d,g_val:%d,&g_val:%p\n",\
                                        getpid(),getppid(),g_val,&g_val);
                        sleep(1);
                }
        }
}

同样的地址不同的值

 这里的地址绝对不是物理地址，而是虚拟地址！

几乎所有的语言，如果他有物理地址，一定不是物理地址，而是虚拟地址（线性地址）！

进程地址空间

        用户空间 vs 内核空间

        在32位下，一个进程的地址空间，取值范围是0x0000 0000 ~ 0xFFFF FFFF

        [0，3G]：用户空间

        [3G，4G]：内核空间

        内行核中的地址空间，本质将来也一定是一种数据结构！

        将来一个特定的进程关联起来！

        地址空间和页表（用户级）是每一个进程都私有一份，

        只要保证，每一个进程的页表，映射的是物理内存的不同区域，就能做到，进程之间不会互相干扰，保证进程的独立性！

        可执行程序其实编译时内部已经有地址了。

        地址空间不要仅仅理解成为是os内部要遵守的，其实编译器也要遵守！！！，即编译器编译代码的时候，就已经给我们形成了各个区域代码区，数据区。并且，采用和linux内核中一样的编址方式，给每一个变量，每一行代码都进行了编址，故，程序在变异的时候，每一个字段早已经具有了一个虚拟的地址。

        程序内部的地址，用的是编译器编译好的虚拟地址

        当程序加载到内存的时候，每行代码，每个变量边具有了一个物理地址！

         cpu内部找到的是虚拟地址！

 为什么要存在地址空间？
1、凡是非法的访问或者映射，os都会识别到，并终止你这个进程！

        有效的保护了物理内存

        因为地址空间和页表是os创建并维护的！意味着凡是使用地址空间和页表进行映射，也一定要在os的监管之下进行访问！同时保护了物理内存中的所有的合法数据包括各个进程，以及内核的相关有效数据！

 2、因为有地址空间的存在，应为有页表的映射的存在，我们的物理内存中，可以对未来的数据进行任意位置的加载，让内存的分配和进程的管理，可以做到没有关系，内存管理模块和进程管理模块完成了解耦合！

        我们在c、c++语言上new，malloc空间的存在，本质上是在虚拟地址空间，因为当你申请了物理空间，但是如果不立马，会造成空间的浪费！

        本质上，因为有地址空间的存在，所以上层申请空间，其实是在地址空间上申请的，物理内存可以甚至一个字节都不给你！而当你真正进行对物理地址空间访问的时候，才执行真正的内存管理相关算法！帮你申请内存，构建页表映射关系！这就是传说中的缺页中断！

         延迟分配，提高了整机效率，内存几乎完全消耗！

3. 因为在物理内存中，理论上可以任意位置加载，物理内存的几乎所有的数据和代码在内存中是乱序的！因为页表的存在，它可以将地址空间上的虚拟地址和物理地址进行映射，那么所有在进程视角的内存分布，都是有序的！

        结合第二条：进程要访问的物理内存中的数据和代码，可能目前并没有在物理内存中，同样的，也可以让不同的进程映射到不同的物理内存！让我们很容易做到进程的独立性!

        总结，因为有地址空间的存在，每一个进程都认为自己拥有独立的空间，并且各个区域是有序的，进而可以通过页表映射到不同的区域，来实现进程的独立性！每个进程都不知道彼此的存在！