Linux——进程概念
目录
1. 基本概念
2. 描述进程-PCB
2.1 task_struct-PCB的一种
2.2 task_struct内容分类
3. 查看进程
3.1 通过系统目录查看
3.2 通过ps命令查看
4. 通过系统调用获取进程的PID和PPID
5. 通过系统调用来创建子进程
5.1 fork函数
5.2 使用if进行分流
6. Linux进程状态
6.1 运行状态——R
6.2 浅度睡眠状态——S
6.3 深度睡眠状态——D
6.4 暂停状态——T
6.5 僵尸状态——Z
6.6 死亡状态——X
7. 僵尸进程
8. 僵尸进程的危害
9. 孤儿进程
10. 进程优先级
10.1 基本概念
10.2 查看系统进程
10.3 PRI和NI
10.4 查看进程优先级信息
10.5 通过top命令修改进程的nice值
10.6 通过renice命令修改进程的nice值
10.7 四个重要概念
11. 环境变量
11.1 基本概念
11.2 常见的环境变量
11.3 查看环境变量
11.4 测试PATH
11.5 测试HOME
11.6 测试Shell
11.7 和环境变量相关的命令
11.8 环境变量的组织方式
11.9 通过代码获取环境变量
11.10 通过系统调用来获取环境变量
12. 程序地址空间
13. 进程地址空间
14. Linux2.6内核进程调度队列
14.1 优先级
14.2 活动队列
14.3 过期队列
14.4 active指针和expired指针
1. 基本概念
这里直接从内核的角度给出“进程”的概念：担当分配系统资源（CPU时间，内存）的实体。
我们在写完代码后，将代码编译链接形成可执行程序，那么可执行程序是如何运行起来的呢？
答案是要将它加载到内存中去，这个时候系统就会为我们创建进程PCB，那么什么是PCB呢？
我们使用的指令、工具、自己的程序，只要运行起来，都是进程！
2. 描述进程-PCB
系统当中可以同时存在大量进程，使用命令ps aux便可以显示系统当中存在的进程。
那么我们看到系统中存在很多进程，那么有这么多的进程，系统要不要将它们管理起来呢？
答案的肯定的，那么该如何管理呢？先描述，再组织！
操作系统管理进程也是一样的，操作系统作为管理者是不需要直接和被管理者（进程）直接进行沟通的，当一个进程出现时，操作系统就立马对其进行描述，之后对该进程的管理实际上就是对其描述信息的管理。
进程信息被放在一个叫做进程控制块的数据结构中，可以理解为进程属性的集合，称之为PCB（process control block）。进程的所有属性，都可以在PCB中直接或间接找到。
操作系统将每一个进程都进行描述，形成了一个个的进程控制块（PCB），并将这些PCB以双链表的形式组织起来。
这样一来，对进程的管理就变成了对链表的增删查改了。
由此，这里需要输出一个结论：进程=PCB+自己的代码和数据。
创建一个进程实际上就是先将该进程的代码和数据加载到内存，紧接着操作系统对该进程进行描述形成对应的PCB，并将这个PCB插入到该双链表当中。
而退出一个进程实际上就是先将该进程的PCB从该双链表当中删除，然后操作系统再将内存当中属于该进程的代码和数据进行释放或是置为无效。
2.1 task_struct-PCB的一种
Linux是用C语言写的，那么大家可以思考一下，C语言中是用什么来描述对象的，答案是结构体，所以task_struct是一个结构体。
- PCB实际上是对进程控制块的统称，在Linux中描述进程的结构体叫做task_struct。
- task_struct是Linux内核的一种数据结构，它会被装载到RAM（内存）里并且包含进程的信息。
2.2 task_struct内容分类
3. 查看进程
3.1 通过系统目录查看
在根目录下有一个名为proc的系统文件夹。
文件夹当中包含大量进程信息，其中有些子目录的目录名为数字。
3.2 通过ps命令查看
这个就是上面提到的，我们可以使用“ps aux”命令来查看进程信息。
ps命令与grep命令搭配使用，即可只显示某一进程的信息。
4. 通过系统调用获取进程的PID和PPID
通过使用系统调用函数，getpid和getppid即可分别获取进程的PID和PPID。
我们可以通过代码来进行测试：
这里大家可以看到我们循环打印的PID和PPID。说明一下，这里包括下面的的代码都是在VScode上写的，VScode上也可以调出终端（Ctrl+~）。
5. 通过系统调用来创建子进程
5.1 fork函数
fork是一个系统调用级别的函数，其功能就是创建一个子进程。
大家仔细观察上面的代码，结果循环打印了两条语句，其中第一条是proc.exe这个可执行程序运行起来后产生的进程信息，第二条是fork创建的子进程的信息。这里大家注意proc进程的PID和fork的PPID是一样的，而我们知道PID是自己的，PPID是当前进程的父进程的，这里就说明了它们之间的父子关系。
每出现一个进程，操作系统就会为其创建PCB，fork函数创建的进程也不例外。
我们知道加载到内存当中的代码和数据是属于父进程的，那么fork函数创建的子进程的代码和数据又从何而来呢？
大家来看下面的代码
通过上面的运行结果，我们可以得到结论：
使用fork函数创建子进程，在fork函数之前的代码被父进程执行，而fork函数之后的代码，则默认情况下父子进程都可以执行。
需要注意的是，父子进程虽然代码共享，但是父子进程的数据各自开辟空间（采用写时拷贝）。
5.2 使用if进行分流
上面我们说到，fork之后的代码父子都可以执行，那么父子进程都做一样的事，子进程就失去了意义，我们需要让父子进程各干各的事，互不干扰。
那么一般情况下，我们就需要使用if来进行分流。
fork函数的返回值：
1、如果子进程创建成功，在父进程中返回子进程的PID，而在子进程中返回0。
2、如果子进程创建失败，则在父进程中返回 -1。
既然父进程和子进程获取到fork函数的返回值不同，那么我们就可以据此来让父子进程执行不同的代码，从而做不同的事。
#include<stdio.h>
#include<unistd.h>
#include <sys/types.h>
int main()
{
printf("I am running!\n");
pid_t id=fork();
if(id==0)
{
//子进程
while(1)
{
printf("I am child\n");
sleep(1);
}
}
else if(id>0)
{
//父进程
while(1)
{
printf("I am father\n");
sleep(1);
}
}
else
{
printf("fork fail");
}
return 0;
}
大家可以看到，父子进程在执行各自的代码，这样就实现了分流。
6. Linux进程状态
这里我们具体谈一下Linux操作系统中的进程状态，Linux操作系统的源代码当中对于进程状态有如下定义：
/*
* 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 *task_state_array[] = {
"R (running)", /* 0*/
"S (sleeping)", /* 1*/
"D (disk sleep)", /* 2*/
"T (stopped)", /* 4*/
"T (tracing stop)", /* 8*/
"Z (zombie)", /* 16*/
"X (dead)" /* 32*/
};
tip： 进程的当前状态是保存到自己的进程控制块（PCB）当中的，在Linux操作系统当中也就是保存在task_struct当中的。
在Linux操作系统当中我们可以通过 ps aux 或 ps axj 命令查看进程的状态。
6.1 运行状态——R
一个进程处于运行状态（running），并不意味着进程一定处于运行当中，运行状态表明一个进程要么在运行中，要么在运行队列里。也就是说，可以同时存在多个R状态的进程。
tip： 所有处于运行状态，即可被调度的进程，都被放到运行队列当中，当操作系统需要切换进程运行时，就直接在运行队列中选取进程运行。
6.2 浅度睡眠状态——S
一个进程处于浅度睡眠状态（sleeping），意味着该进程正在等待某件事情的完成，处于浅度睡眠状态的进程随时可以被唤醒，也可以被杀掉（这里的睡眠有时候也可叫做可中断睡眠（interruptible sleep））。
代码当中调用sleep函数进行休眠100秒，在这期间我们若是查看该进程的状态，则会看到该进程处于浅度睡眠状态。
cp@hcss-ecs-348a:~$ ps aux | head -1 && ps aux | grep proc | grep -v grep
而处于浅度睡眠状态的进程是可以被杀掉的，我们可以使用kill命令，发送9号信号，将该进程杀掉。
6.3 深度睡眠状态——D
一个进程处于深度睡眠状态（disk sleep），表示该进程不会被杀掉，即便是操作系统也不行，只有该进程自动唤醒才可以恢复。该状态有时候也叫不可中断睡眠状态（uninterruptible sleep），处于这个状态的进程通常会等待IO的结束。
例如，某一进程要求对磁盘进行写入操作，那么在磁盘进行写入期间，该进程就处于深度睡眠状态，是不会被杀掉的，因为该进程需要等待磁盘的回复（是否写入成功）以做出相应的应答。（磁盘休眠状态）。
6.4 暂停状态——T
在Linux当中，我们可以通过发送SIGSTOP信号使进程进入暂停状态（stopped），发送SIGCONT信号可以让处于暂停状态的进程继续运行。
例如，我们对一个进程发送SIGSTOP信号，该进程就进入到了暂停状态。
我们再对该进程发送SIGCONT信号，该进程就继续运行了。
tip： 使用kill命令可以列出当前系统所支持的信号集。
6.5 僵尸状态——Z
当一个进程将要退出的时候，在系统层面，该进程曾经申请的资源并不是立即被释放，而是要暂时存储一段时间，以供操作系统或是其父进程进行读取，如果退出信息一直未被读取，则相关数据是不会被释放掉的，一个进程若是正在等待其退出信息被读取，那么我们称该进程处于僵尸状态（zombie）。
首先，僵尸状态的存在是必要的，因为进程被创建的目的就是完成某项任务，那么当任务完成的时候，调用方是应该知道任务的完成情况的，所以必须存在僵尸状态，使得调用方得知任务的完成情况，以便进行相应的后续操作。
例如，我们写代码时都在主函数最后返回0。
实际上这个0就是返回给操作系统的，告诉操作系统代码顺利执行结束。
在Linux操作系统当中，我们可以通过使用“echo $?”命令获取最近一次进程退出时的退出码。
tip： 进程退出的信息（例如退出码），是暂时被保存在其进程控制块当中的，在Linux操作系统中也就是保存在该进程的task_struct当中。
6.6 死亡状态——X
死亡状态只是一个返回状态，当一个进程的退出信息被读取后，该进程所申请的资源就会立即被释放，该进程也就不存在了，所以你不会在任务列表当中看到死亡状态（dead）。
7. 僵尸进程
前面说到，一个进程若是正在等待其退出信息被读取，那么我们称该进程处于僵尸状态。而处于僵尸状态的进程，我们就称之为僵尸进程。
大家来看下面一段代码；
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include <sys/types.h>
int main()
{
printf("I am running\n");
pid_t id=fork();
if(id==0)
{
//子进程
int count=5;
while(count--)
{
printf("I am child——PID:%d,PPID:%d,count:%d\n",getpid(),getppid(),count);
sleep(1);
}
printf("child quit\n");
exit(1);
}
else if(id>0)
{
//父进程
while(1)
{
printf("I am father——PID:%d,PPID:%d\n",getpid(),getppid());
sleep(1);
}
}
else
{
printf("fork fail");
}
return 0;
}
对于以上代码，fork函数创建的子进程在打印5次信息后会退出，而父进程会一直打印信息。也就是说，子进程退出了，父进程还在运行，但父进程没有读取子进程的退出信息，那么此时子进程就进入了僵尸状态。
我们可以打开监控脚本来查看进程的状态：
while :; do ps axj | head -1 && ps axj | grep proc.exe | grep -v grep;echo "######################";sleep 1;done
检测后即可发现，当子进程退出后，子进程的状态就变成了僵尸状态。
8. 僵尸进程的危害
1.僵尸进程的退出状态必须一直维持下去，因为它要告诉其父进程相应的退出信息。可是父进程一直不读取，那么子进程也就一直处于僵尸状态。
2.僵尸进程的退出信息被保存在task_struct(PCB)中，僵尸状态一直不退出，那么PCB就一直需要进行维护。
3.若是一个父进程创建了很多子进程，但都不进行回收，那么就会造成资源浪费，因为数据结构对象本身就要占用内存。
4.僵尸进程申请的资源无法进行回收，那么僵尸进程越多，实际可用的资源就越少，也就是说，僵尸进程会导致内存泄漏。
9. 孤儿进程
在Linux当中的进程关系大多数是父子关系，若子进程先退出而父进程没有对子进程的退出信息进行读取，那么我们称该进程为僵尸进程。但若是父进程先退出，那么将来子进程进入僵尸状态时就没有父进程对其进行处理，此时该子进程就称之为孤儿进程。
若是一直不处理孤儿进程的退出信息，那么孤儿进程就会一直占用资源，此时就会造成内存泄漏。因此，当出现孤儿进程的时候，孤儿进程会被1号进程领养，此后当孤儿进程进入僵尸状态时就由1号进程进行处理回收。
例如，对于以下代码，fork函数创建的子进程会一直打印信息，而父进程在打印5次信息后会退出，此时该子进程就变成了孤儿进程。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include <sys/types.h>
int main()
{
printf("I am running\n");
pid_t id=fork();
if(id>0)
{
//父进程
int count=5;
while(count--)
{
printf("I am father——PID:%d,PPID:%d,count:%d\n",getpid(),getppid(),count);
sleep(1);
}
printf("father quit\n");
exit(1);
}
else if(id==0)
{
//子进程
while(1)
{
printf("I am child——PID:%d,PPID:%d\n",getpid(),getppid());
sleep(1);
}
}
else
{
printf("fork fail");
}
return 0;
}
大家看上面代码的运行结果，当父进程没退出的时候，子进程的PPID与父进程的PID是一样的；当父进程退出的时候，我们可以看到子进程的PPID变成了1，也就是被1号进程领养了。
10. 进程优先级
10.1 基本概念
什么是优先级？
优先级实际上就是获取某种资源的先后顺序，而进程优先级实际上就是进程获取CPU资源分配的先后顺序，就是指进程的优先权（priority），优先权高的进程有优先执行的权力。
优先级存在的原因？
优先级存在的主要原因就是资源是有限的，而存在进程优先级的主要原因就是CPU资源是有限的，一个CPU一次只能跑一个进程，而进程是可以有多个的，所以需要存在进程优先级，来确定进程获取CPU资源的先后顺序。
10.2 查看系统进程
在Linux或者Unix操作系统中，用ps -l命令会类似输出以下几个内容：
列出的信息当中有几个重要的信息，如下：
UID：代表执行者的身份。
PID：代表这个进程的代号。
PPID：代表这个进程是由哪个进程发展衍生而来的，亦即父进程的代号。
PRI：代表这个进程可被执行的优先级，其值越小越早被执行。
NI：代表这个进程的nice值。
10.3 PRI和NI
PRI代表进程的优先级（priority），通俗点说就是进程被CPU执行的先后顺序，该值越小进程的优先级别越高。
NI代表的是nice值，其表示进程可被执行的优先级的修正数值。
PRI值越小越快被执行，当加入nice值后，将会使得PRI变为：PRI(new) = PRI(old) + NI。
若NI值为负值，那么该进程的PRI将变小，即其优先级会变高。
调整进程优先级，在Linux下，就是调整进程的nice值。
NI的取值范围是-20至19，一共40个级别。
注意： 在Linux操作系统当中，PRI(old)默认为80，即PRI = 80 + NI。
10.4 查看进程优先级信息
当我们创建一个进程后，我们可以使用ps -al命令查看该进程优先级的信息。
注意： 在Linux操作系统中，初始进程一般优先级PRI默认为80，NI默认为0。
10.5 通过top命令修改进程的nice值
top命令就相当于Windows操作系统中的任务管理器，它能够动态实时的显示系统当中进程的资源占用情况。
使用top命令后按“r”键，会要求你输入待调整nice值的进程的PID。
输入进程PID并回车后，会要求你输入调整后的nice值。
输入nice值后回车，再按“q”即可退出，如果我们这里输入的nice值为10，那么此时我们再用ps命令查看进程的优先级信息，即可发现进程的NI变成了10，PRI变成了90（80+NI）。
注意： 若是想将NI值调为负值，也就是将进程的优先级调高，需要使用sudo命令提升权限。
10.6 通过renice命令修改进程的nice值
使用renice命令，后面跟上更改后的nice值和进程的PID即可。
注意： 若是想使用renice命令将NI值调为负值，也需要使用sudo命令提升权限。
10.7 四个重要概念
1、竞争性： 系统进程数目众多，而CPU资源只有少量，甚至1个，所以进程之间是具有竞争属性的。为了高效完成任务，更合理竞争相关资源，便有了优先级。
2、独立性： 多进程运行，需要独享各种资源，多进程运行期间互不干扰。
3、并行： 多个进程在多个CPU下分别同时进行运行，这称之为并行。
4、并发： 多个进程在一个CPU下采用进程切换的方式，在一段时间之内，让多个进程都得以推进，称之为并发。
11. 环境变量
11.1 基本概念
环境变量（environment variables）一般是指在操作系统中用来指定操作系统运行环境的一些参数。
环境变量通常具有某些特殊用途，并且在系统当中通常具有全局特性。
11.2 常见的环境变量
PATH：指定命令的搜索路径。
HOME：指定用户的主工作目录（即用户登录到Linux系统中的默认所处目录）。
SHELL：当前Shell，它的值通常是/bin/bash。
11.3 查看环境变量
echo $NAME //NAME为待查看的环境变量名称
例如，查看环境变量PATH。
11.4 测试PATH
大家有没有想过这样一个问题：为什么执行ls命令的时候不用带./就可以执行，而我们自己生成的可执行程序必须要在前面带上./才可以执行？
容易理解的是，要执行一个可执行程序必须要先找到它在哪里，既然不带./就可以执行ls命令，说明系统能够通过ls名称找到ls的位置，而系统是无法找到我们自己的可执行程序的，所以我们必须带上./，以此告诉系统该可执行程序位于当前目录下。
而系统就是通过环境变量PATH来找到ls命令的，查看环境变量PATH我们可以看到如下内容：
可以看到环境变量PATH当中有多条路径，这些路径由冒号隔开，当你使用ls命令时，系统就会查看环境变量PATH，然后默认从左到右依次在各个路径当中进行查找。
而ls命令实际就位于PATH当中的某一个路径下，所以就算ls命令不带路径执行，系统也是能够找到的。
那既然这样，我们可不可以让我们自己的可执行程序也想命令一样不带路径就可以执行呢？
答案当然是OK的；
方式一：将可执行程序拷贝到环境变量PATH的某一路径下。
sudo cp proc /usr/bin既然在未指定路径的情况下系统会根据环境变量PATH当中的路径进行查找，那我们就可以将我们的可执行程序拷贝到PATH的某一路径下，此后我们的可执行程序不带路径系统也可以找到了。
方式二：将可执行程序所在的目录导入到环境变量PATH当中。
将可执行程序所在的目录导入到环境变量PATH当中，这样一来，没有指定路径时系统就会来到该目录下进行查找了。
export PATH=$PATH:/home/cp/test1
将可执行程序所在的目录导入到环境变量PATH当中后，位于该目录下的可执行程序也就可以在不带路径的情况下执行了。
11.5 测试HOME
任何一个用户在运行系统登录时都有自己的主工作目录（家目录），环境变量HOME当中即保存的该用户的主工作目录。
上面展示了普通用户和超级用户下，我们对应的工作目录。
11.6 测试Shell
我们在Linux操作系统当中所敲的各种命令，实际上需要由命令行解释器进行解释，而在Linux当中有许多种命令行解释器（例如bash、sh），我们可以通过查看环境变量SHELL来知道自己当前所用的命令行解释器的种类。
而该命令行解释器实际上是系统当中的一条命令，当这个命令运行起来变成进程后就可以为我们进行命令行解释。
11.7 和环境变量相关的命令
1、echo：显示某个环境变量的值。
2、export：设置一个新的环境变量。
3、env：显示所有的环境变量。
部分环境变量说明：
4、set：显示本地定义的shell变量和环境变量。
5、unset：清除环境变量。
11.8 环境变量的组织方式
每个程序都会收到一张环境变量表，环境变量表是一个字符指针数组，每个指针指向一个以’\0’结尾的环境字符串，最后一个字符指针为空。
11.9 通过代码获取环境变量
大家有没有思考过main函数有没有参数？
main函数其实有三个参数，只是我们平时基本不用它们，所以一般情况下都没有写出来。
我们可以在Windows下的编译器进行验证，当我们调试代码的时候，若是一直使用逐步调试，那么最终会来到调用main函数的地方。
这里我们先来讨论main函数的前两个参数。
main函数的第二个参数是一个字符指针数组，数组当中的第一个字符指针存储的是可执行程序的位置，其余字符指针存储的是所给的若干选项，最后一个字符指针为空，而main函数的第一个参数代表的就是字符指针数组当中的有效元素个数。
下面我们来写一个测试demo；
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[], char* envp[])
{
if(argc > 1)
{
if(strcmp(argv[1], "-a") == 0)
{
printf("you used -a option...\n");
}
else if(strcmp(argv[1], "-b") == 0)
{
printf("you used -b option...\n");
}
else
{
printf("you used unrecognizable option...\n");
}
}
else
{
printf("you did not use any option...\n");
}
return 0;
}
大家可以看到，我们输入不同的选项，可以执行不同的语句（功能）。
下面我们再来谈谈main函数的第三个参数。
main函数的第三个参数接收的实际上就是环境变量表，我们可以通过main函数的第三个参数来获取系统的环境变量。
大家可以看到代码的运行结果就是各个环境变量的值。
除了使用main函数的第三个参数来获取环境变量以外，我们还可以通过第三方变量environ来获取。
这样也可以得到环境变量的值。
注意： libc中定义的全局变量environ指向环境变量表，environ没有包含在任何头文件中，所以在使用时要用extern进行声明。
11.10 通过系统调用来获取环境变量
使用getenv函数获取环境变量PATH的值。
getenv函数可以根据所给环境变量名，在环境变量表当中进行搜索，并返回一个指向相应值的字符串指针。
12. 程序地址空间
这张图相信大家肯定不陌生，在Linux操作系统中，我们可以通过以下代码对该布局图进行验证：
#include <stdio.h>
#include <stdlib.h>
int g_unval;
int g_val = 100;
int main(int argc, char* argv[], char* env[])
{
const char* str = "helloworld";
printf("code addr: %p\n", main);
printf("init global addr: %p\n", &g_val);
printf("uninit global addr: %p\n", &g_unval);
static int test = 10;
char* heap_mem = (char*)malloc(10);
char* heap_mem1 = (char*)malloc(10);
char* heap_mem2 = (char*)malloc(10);
char* heap_mem3 = (char*)malloc(10);
printf("heap addr: %p\n", heap_mem); //heap_mem(0), &heap_mem(1)
printf("heap addr: %p\n", heap_mem1); //heap_mem(0), &heap_mem(1)
printf("heap addr: %p\n", heap_mem2); //heap_mem(0), &heap_mem(1)
printf("heap addr: %p\n", heap_mem3); //heap_mem(0), &heap_mem(1)
printf("test static addr: %p\n", &test); //heap_mem(0), &heap_mem(1)
printf("stack addr: %p\n", &heap_mem); //heap_mem(0), &heap_mem(1)
printf("stack addr: %p\n", &heap_mem1); //heap_mem(0), &heap_mem(1)
printf("stack addr: %p\n", &heap_mem2); //heap_mem(0), &heap_mem(1)
printf("stack addr: %p\n", &heap_mem3); //heap_mem(0), &heap_mem(1)
printf("read only string addr: %p\n", str);
for (int i = 0; i < argc; 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;
}
大家可以看到打印的结果和图上描述的是一致的。
下面我们来看一段的代码：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.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=10;
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;
}下面我们来看运行结果：
大家重点关注它们的地址，发现地址是一样的。
代码当中用fork函数创建了一个子进程，其中让子进程相将全局变量g_val该从0改为10后打印，而父进程先休眠1秒钟，然后再打印全局变量的值。
按道理来说子进程打印的全局变量的值为10，而父进程是在子进程将全局变量改后再打印的全局变量，那么也应该是10，但是大家可以看到我们打印的结果是不一样的，父进程打印的还是0，子进程打印的10。
但是它们地址又都是一样的，那这里就比较奇怪了，同一个地址，为啥值还不一样。
如果说我们是在同一个物理地址处获取的值，那必定是相同的，而现在在同一个地址处获取到的值却不同，这只能说明我们打印出来的地址绝对不是物理地址！！！
实际上，我们在语言层面上打印出来的地址都不是物理地址，而是虚拟地址。物理地址用户一概是看不到的，是由操作系统统一进行管理的。
所以就算父子进程当中打印出来的全局变量的地址（虚拟地址）相同，但是两个进程当中全局变量的值却是不同的。
注意： 虚拟地址和物理地址之间的转化由操作系统完成。这个后面我们会知道，是利用页表进行地址转化的。
13. 进程地址空间
我们之前将那张布局图称为程序地址空间实际上是不准确的，那张布局图实际上应该叫做进程地址空间，进程地址空间本质上是内存中的一种内核数据结构，在Linux当中进程地址空间具体由结构体mm_struct实现。
进程地址空间就类似于一把尺子，尺子的刻度由0x00000000到0xffffffff，尺子按照刻度被划分为各个区域，例如代码区、堆区、栈区等。而在结构体mm_struct当中，便记录了各个边界刻度，例如代码区的开始刻度与结束刻度，如下图所示：
在结构体mm_struct当中，各个边界刻度之间的每一个刻度都代表一个虚拟地址，这些虚拟地址通过页表映射与物理内存建立联系。由于虚拟地址是由0x00000000到0xffffffff线性增长的，所以虚拟地址又叫做线性地址。
每个进程被创建时，其对应的进程控制块（task_struct）和进程地址空间（mm_struct）也会随之被创建。
而操作系统可以通过进程的task_struct找到其mm_struct，因为task_struct当中有一个结构体指针存储的是mm_struct的地址。
而当子进程刚刚被创建时，子进程和父进程的数据和代码是共享的，即父子进程的代码和数据通过页表映射到物理内存的同一块空间。只有当父进程或子进程需要修改数据时，才将父进程的数据在内存当中拷贝一份，然后再进行修改。
例如，子进程需要将全局变量g_val改为200，那么此时就在内存的某处存储g_val的新值，并且改变子进程当中g_val的虚拟地址通过页表映射后得到的物理地址即可。
这种在需要进行数据修改时再进行拷贝的技术，称为写时拷贝技术。
下面我们来介绍一下写时拷贝：
1. 为什么要存在写时拷贝？
进程具有独立性，多进程运行，需要独享各种资源，多进程运行期间互不干扰，不能让子进程的修改影响到父进程。
2. 为什么不在创建子进程的时候就进行数据的拷贝？
子进程不一定会使用父进程的所有数据，并且在子进程不对数据进行写入的情况下，没有必要对数据进行拷贝，我们应该按需分配，在需要修改数据的时候再分配（延时分配），这样可以高效的使用内存空间。
3. 代码会不会进行写时拷贝？
大多数情况下是不会的，但这并不代表代码不能进行写时拷贝，例如在进行进程替换的时候，则需要进行代码的写时拷贝。
那么为什么要有进程地址空间呢？
1、有了进程地址空间后，保护了物理内存中的所有合法数据。凡是想使用地址空间和页表进行映射， 也⼀定要在OS的监管之下来进行访问！！
2、有了进程地址空间后，每个进程都认为看得到都是相同的空间范围，包括进程地址空间的构成和内部区域的划分顺序等都是相同的，这样一来我们在编写程序的时候就只需关注虚拟地址，而无需关注数据在物理内存当中实际的存储位置。
3、有了进程地址空间后，每个进程都认为自己在独占内存，这样能更好的完成进程的独立性以及合理使用内存空间（当实际需要使用内存空间的时候再在内存进行开辟），我们的物理内存中可以对未来的数据进行任意位置的加载，将进程调度与内存管理进行解耦或分离。
这里总结一下：当我们创建进程时，系统就会为我们自动创建task_struct，mm_struct，页表。
14. Linux2.6内核进程调度队列
一个CPU拥有一个runqueue
14.1 优先级
queue下标说明：
普通优先级：100~139。
实时优先级：0~99。
我们进程的都是普通的优先级，前面说到nice值的取值范围是-20~19，共40个级别，依次对应queue当中普通优先级的下标100~139。
注意： 实时优先级对应实时进程，实时进程是指先将一个进程执行完毕再执行下一个进程，现在基本不存在这种机器了，所以对于queue当中下标为0~99的元素我们不关心。
14.2 活动队列
时间片还没有结束的所有进程都按照优先级放在活动队列当中，其中nr_active代表总共有多少个运行状态的进程，而queue[140]数组当中的每一个元素就是一个进程队列，相同优先级的进程按照先进先出规则进行排队调度。
调度过程如下：
从0下标开始遍历queue[140]。
找到第一个非空队列，该队列必定为优先级最高的队列。
拿到选中队列的第一个进程，开始运行，调度完成。
接着拿到选中队列的第二个进程进行调度，直到选中进程队列当中的所有进程都被调度。
继续向后遍历queue[140]，寻找下一个非空队列。
bitmap[5]：queue数组当中一共有140个元素，即140个优先级，一共140个进程队列，为了提高查找非空队列的效率，就可以用5×32个比特位表示队列是否为空，这样一来便可以大大提高查找效率。
14.3 过期队列
• 过期队列和活动队列结构⼀模⼀样。
• 过期队列上放置的进程，都是时间片耗尽的进程。
• 当活动队列上的进程都被处理完毕之后，对过期队列的进程进行时间片重新计算。
14.4 active指针和expired指针
• active指针永远指向活动队列
• expired指针永远指向过期队列
• 可是活动队列上的进程会越来越少，过期队列上的进程会越来越多，因为进程时间片到期时⼀直 都存在的。
• 没关系，在合适的时候，只要能够交换active指针和expired指针的内容，就相当于有具有了⼀批 新的活动进程！
总结： 在系统当中查找一个最合适调度的进程的时间复杂度是一个常数，我们本质上进行的都是数组的增删差改，不会随着进程增多而导致时间成本增加，我们称之为进程调度的O(1)算法。