Linux系统编程—进程概念

第一章：冯诺依曼体系结构

我们常见的计算机，如笔记本。我们不常见的计算机，如服务器，大部分都遵守冯诺依曼体系。

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

• 输入单元：包括键盘, 鼠标，扫描仪, 写板等
• 中央处理器(CPU)：含有运算器和控制器等
• 输出单元：显示器，打印机等

关于冯诺依曼，必须强调几点：

• 这里的存储器指的是内存
• 不考虑缓存情况，这里的CPU能且只能对内存进行读写，不能访问外设(输入或输出设备)
• 外设(输入或输出设备)要输入或者输出数据，也只能写入内存或者从内存中读取。
• 一句话，所有设备都只能直接和内存打交道。

注意：
对冯诺依曼的理解，不能停留在概念上，要深入到对软件数据流理解上，请解释，从你登录上qq开始和某位朋友聊天开始，数据的流动过程。从你打开窗口，开始给他发消息，到他的到消息之后的数据流动过程。如果是在qq上发送文件呢？

第二章：操作系统(Operator System)

2-1 概念

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

• 内核（进程管理，内存管理，文件管理，驱动管理）
• 其他程序（例如函数库，shell程序等等）

2-2 设计OS的目的

对下，与硬件交互，管理所有的软硬件资源

对上，为用户程序（应用程序）提供一个良好的执行环境

2-3 核心功能

在整个计算机软硬件架构中，操作系统的定位是：一款纯正的"搞管理"的软件

2-4 如何理解 "管理"

总结

计算机管理硬件

1. 描述起来，用struct结构体
2. 组织起来，用链表或其他高效的数据结构

2-5 系统调用和库函数概念

• 在开发角度，操作系统对外会表现为一个整体，但是会暴露自己的部分接口，供上层开发使用，这部分由操作系统提供的接口，叫做系统调用。
• 系统调用在使用上，功能比较基础，对用户的要求相对也比较高，所以，有心的开发者可以对部分系统调用进行适度封装，从而形成库，有了库，就很有利于更上层用户或者开发者进行二次开发。

第三章：进程

3-1 基本概念与基本操作

• 课本概念：程序的一个执行实例，正在执行的程序等
• 内核观点：担当分配系统资源（CPU时间，内存）的实体。
• 当前：进程 = 内核数据结构(task_struct) + 自己的程序代码和数据

3-1-2 描述进程-PCB

基本概念

• 进程信息被放在一个叫做进程控制块的数据结构中，可以理解为进程属性的集合。
• 课本上称之为PCB（process control block），Linux操作系统下的PCB是: task_struct

task_struct-PCB的一种

• 在Linux中描述进程的结构体叫做task_struct。
• task_struct是Linux内核的一种数据结构，它会被装载到RAM(内存)里并且包含着进程的信息。

3-1-3 task_ struct

内容分类

• 标示符: 描述本进程的唯一标示符，用来区别其他进程。
• 状态: 任务状态，退出代码，退出信号等。
• 优先级: 相对于其他进程的优先级。
• 程序计数器: 程序中即将被执行的下一条指令的地址。
• 内存指针: 包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块的指针
• 上下文数据: 进程执行时处理器的寄存器中的数据[休学例子，要加图CPU，寄存器]。
• I／O状态信息: 包括显示的I/O请求,分配给进程的I／O设备和被进程使用的文件列表。
• 记账信息: 可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号等。
• 其他信息

组织进程

可以在内核源代码里找到它。所有运行在系统里的进程都以task_struct链表的形式存在内核里。

3-1-4 查看进程

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

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

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

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main() {
	while (1) {
		sleep(1);
	}
	return 0;
}

3-1-5 通过系统调用获取进程标示符

• 进程id（PID）
• 父进程id（PPID）

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main() {
	printf("pid: %d\n", getpid());
	printf("ppid: %d\n", getppid());
	return 0;
}

3-1-6 通过系统调用创建进程-fork初识

• 运行 man fork 认识fork
• 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;
}

fork函数的作用与使用场景

fork返回值的原因

fork如何返回两次

关于fork函数的理解

3-2 进程状态

3-2-1 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* 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中S状态和D状态的区别

Linux中Z状态和X状态的区别

3-2-2 进程状态查看

ps aux / ps axj 命令

• a：显示⼀个终端所有的进程，包括其他用户的进程。
• x：显示没有控制终端的进程，例如后台运行的守护进程。
• j：显示进程归属的进程组ID、会话ID、父进程ID，以及与作业控制相关的信息
• u：以用户为中心的格式显示进程信息，提供进程的详细信息，如用户、CPU和内存使⽤情况等

3-2-3 Z(zombie)-僵尸进程

• 僵死状态（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;
}

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

开始测试

看到结果

3-2-4 僵尸进程危害

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

3-2-5 孤儿进程

• 父进程如果提前退出，那么子进程后退出，进入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;
}

3-3 进程优先级

3-3-1 基本概念

• cpu资源分配的先后顺序，就是指进程的优先权（priority）。
• 优先权高的进程有优先执行权利。配置进程优先权对多任务环境的linux很有用，可以改善系统性能。
• 还可以把进程运行到指定的CPU上，这样一来，把不重要的进程安排到某个CPU，可以大大改善系统整体性能。

3-3-2 查看系统进程

在linux或者unix系统中，用ps --l命令则会类似输出以下几个内容：

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

• UID : 代表执行者的身份
• PID : 代表这个进程的代号
• PPID ：代表这个进程是由哪个进程发展衍生而来的，亦即父进程的代号
• PRI ：代表这个进程可被执行的优先级，其值越小越早被执行
• NI ：代表这个进程的nice值

3-3-3 PRI and NI

• PRI也还是比较好理解的，即进程的优先级，或者通俗点说就是程序被CPU执行的先后顺序，此值越小进程的优先级别越高
• 那NI呢?就是我们所要说的nice值了，其表示进程可被执行的优先级的修正数值
• PRI值越小越快被执行，那么加入nice值后，将会使得PRI变为：PRI(new)=PRI(old)+nice
• 这样，当nice值为负值的时候，那么该程序将会优先级值将变小，即其优先级会变高，则其越快被执行
• 所以，调整进程优先级，在Linux下，就是调整进程nice值
• nice其取值范围是-20至19，一共40个级别。

3-3-4 PRI vs NI

• 需要强调一点的是，进程的nice值不是进程的优先级，他们不是一个概念，但是进程nice值会影响到进程的优先级变化。
• 可以理解nice值是进程优先级的修正修正数据

3-3-5 查看进程优先级的命令

用top命令更改已存在进程的nice：

• top
• 进入top后按"r"-->输入进程PID-->输入nice值

注意：

其他调整优先级的命令：nice，renice

系统函数：

#include <sys/time.h>
#include <sys/resource.h>
int getpriority(int which, int who);
int setpriority(int which, int who, int prio);

3-3-6 补充概念-竞争、独立、并行、并发

• 竞争性: 系统进程数目众多，而CPU资源只有少量，甚至1个，所以进程之间是具有竞争属性的。为了高效完成任务，更合理竞争相关资源，便具有了优先级
• 独立性: 多进程运行，需要独享各种资源，多进程运行期间互不干扰
• 并行: 多个进程在多个CPU下分别，同时进行运行，这称之为并行
• 并发: 多个进程在一个CPU下采用进程切换的方式，在一段时间之内，让多个进程都得以推进，称之为并发

进程切换

CPU上下文切换：其实际含义是任务切换, 或者CPU寄存器切换。当多任务内核决定运行另外的任务时, 它保存正在运行任务的当前状态, 也就是CPU寄存器中的全部内容。这些内容被保存在任务自己的堆栈中, 入栈工作完成后就把下一个将要运行的任务的当前状况从该任务的栈中重新装入CPU寄存器,并开始下---个任务的运行, 这一过程就是context switch。

什么是进程的上下文

为什么需要进程上下文

3-4 Linux2.6内核进程O(1)调度队列

3-4-1 一个CPU拥有一个runqueue

如果有多个CPU就要考虑进程个数的负载均衡问题

3-4-2 优先级

• 普通优先级：100~139（我们都是普通的优先级，想想nice值的取值范围，可与之对应！）
• 实时优先级：0~99（不关心）

3-4-3 活动队列

• 时间片还没有结束的所有进程都按照优先级放在该队列
• nr_active: 总共有多少个运行状态的进程
• queue[140]: 一个元素就是一个进程队列，相同优先级的进程按照FIFO规则进行排队调度,所以，数组下标就是优先级！
• 从该结构中，选择⼀个最合适的进程，过程是怎么的呢？

1. 从0下表开始遍历queue[140]
2. 找到第一个非空队列，该队列必定为优先级最高的队列
3. 拿到选中队列的第一个进程，开始运行，调度完成！
4. 遍历queue[140]时间复杂度是常数！但还是太低效了！

• bitmap[5]:⼀共140个优先级，⼀共140个进程队列，为了提高查找非空队列的效率，就可以用5*32个比特位表示队列是否为空，这样，便可以大大提高查找效率！

3-4-4 过期队列

• 过期队列和活动队列结构⼀模⼀样
• 过期队列上放置的进程，都是时间片耗尽的进程
• 当活动队列上的进程都被处理完毕之后，对过期队列的进程进⾏时间片重新计算

3-4-5 active指针和expired指针

• active指针永远指向活动队列
• expired指针永远指向过期队列
• 可是活动队列上的进程会越来越少，过期队列上的进程会越来越多，因为进程时间片到期时一直都存在的。
• 没关系，在合适的时候，只要能够交换active指针和expired指针的内容，就相当于有具有了一批新的活动进程！

3-4-6 总结

在系统当中查找一个最合适调度的进程的时间复杂度是一个常数，不随着进程增多而导致时间成本增加，我们称之为进程调度O(1)算法！

第四章：命令行参数和环境变量

4-1 基本概念

• 环境变量(environment variables)一般是指在操作系统中用来指定操作系统运行环境的一些参数
• 如：我们在编写C/C++代码的时候，在链接的时候，从来不知道我们的所链接的动态静态库在哪里，但是照样可以链接成功，生成可执行程序，原因就是有相关环境变量帮助编译器进行查找。
• 环境变量通常具有某些特殊用途，还有在系统当中通常具有全局特性

什么是环境变量

补充概念：命令行参数

4-2 常见环境变量

• PATH : 指定命令的搜索路径
• HOME : 指定用户的主工作目录(即用户登陆到Linux系统中时,默认的目录)
• SHELL : 当前Shell,它的值通常是/bin/bash。

PATH环境变量

4-3 查看环境变量方法

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. 还有什么方法可以不用带路径，直接就可以运行呢？

测试HOME

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

4-4 和环境变量相关的命令

1. echo: 显示某个环境变量值
2. export : 设置一个新的环境变量
3. env : 显示所有环境变量
4. unset : 清除环境变量
5. set : 显示本地定义的shell变量和环境变量

4-5 环境变量的组织方式

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

4-6 通过代码如何获取环境变量

命令行第三个参数

#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声明。

4-7 通过系统调用获取或设置环境变量

环境变量通常具有全局属性，可以被子进程继承下去

#include <stdio.h>
#include <stdlib.h>
int main() {
	char* env = getenv("MYENV");
	if (env) {
		printf("%s\n", env);
	}
	return 0;
}

直接查看，发现没有结果，说明该环境变量根本不存在

导出环境变量

export MYENV="hello world"

再次运行程序，发现结果有了！说明：环境变量是可以被子进程继承下去的！想想为什么

4-9 实验

如果只进行 MYENV＝"helloworld" ,不调用export导出，在用我们的程序查看，会有什么结果？为什么？
普通变量

本地变量&&内建命令

main函数

main函数也是函数，也能被调用。实际上main函数不是程序开始的第一个函数，它也是被其他函数调用，且也可以有参数。

argc是命令行参数表中元素个数

argv是命令行参数表

env是环境变量表

所以我们编写的可执行程序也能像系统默认指令那样。

也可以通过第三个参数获取环境变量

第五章：程序地址空间

5-1 研究平台

• kernel 2.6.32
• 32位平台

5-2 程序地址空间回顾

在讲C语言的时候，画过这样的空间布局图

可是我们对他并不理解！可以先对其进行各区域分布验证：

#include <stdio.h>
#include <unistd.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;
}

$ ./a.out
code addr: 0x40055d
init global addr: 0x601034
uninit global addr: 0x601040
heap addr: 0x1791010
heap addr: 0x1791030
heap addr: 0x1791050
heap addr: 0x1791070
test static addr: 0x601038
stack addr: 0x7ffd0f9a4368
stack addr: 0x7ffd0f9a4360
stack addr: 0x7ffd0f9a4358
stack addr: 0x7ffd0f9a4350
read only string addr: 0x400800
argv[0]: 0x7ffd0f9a4811
env[0]: 0x7ffd0f9a4819
env[1]: 0x7ffd0f9a482e
env[2]: 0x7ffd0f9a4845
env[3]: 0x7ffd0f9a4850
env[4]: 0x7ffd0f9a4860
env[5]: 0x7ffd0f9a486e
$ ./a.out
code addr: 0x40055d
init global addr: 0x601034
uninit global addr: 0x601040
heap addr: 0x1791010
heap addr: 0x1791030
heap addr: 0x1791050
heap addr: 0x1791070
test static addr: 0x601038
stack addr: 0x7ffd0f9a4368
stack addr: 0x7ffd0f9a4360
stack addr: 0x7ffd0f9a4358
stack addr: 0x7ffd0f9a4350
read only string addr: 0x400800
argv[0]: 0x7ffd0f9a4811
env[0]: 0x7ffd0f9a4819
env[1]: 0x7ffd0f9a482e
env[2]: 0x7ffd0f9a4845
env[3]: 0x7ffd0f9a4850
env[4]: 0x7ffd0f9a4860
env[5]: 0x7ffd0f9a486e

5-3 虚拟地址

#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必须负责将 虚拟地址 转化成 物理地址 。

5-4 进程地址空间

所以之前说'程序的地址空间'是不准确的，准确的应该说成 进程地址空间 ，那该如何理解呢？看图：

分页&虚拟地址空间

说明:

上面的图就足矣说名问题，同一个变量，地址相同，其实是虚拟地址相同，内容不同其实是被映射到了不同的物理地址！

父子进程PCB、进程地址空间、页表1

父子进程PCB、进程地址空间、页表2

进程地址空间大小

5-5 虚拟内存管理 - 第一讲

描述linux下进程的地址空间的所有的信息的结构体是 mm_struct （内存描述符）。每个进程只有一个mm_struct结构，在每个进程的 task_struct 结构中，有⼀个指向该进程的mm_struct结构体指针。

struct task_struct {
	struct mm_struct* mm;
	//对于普通的用户进程来说该字段指向他的虚拟地址空间的用户空间部分，对于内核线程来说这部分为NULL。
	
	struct mm_struct* active_mm;
	//该字段是内核线程使用的。当该进程是内核线程时，它的mm字段为NULL，表示没有内存地址空间，
	//可也并不是真正的没有，这是因为所有进程关于内核的映射都是一样的，内核线程可以使用任意进程的地址空间。
}

可以说， mm_struct 结构是对整个用户空间的描述。每一个进程都会有自己独立的 mm_struct ，这样每一个进程都会有自己独立的的地址空间才能互不干扰。先来看看由 task_struct 到mm_struct ，进程的地址空间的分布情况：

定位 mm_struct 文件所在位置和 task_struct 所在路径是一样的，不过他们所在文件是不一样的， mm_struct 所在的文件是 mm_types.h

struct mm_struct {
	/*...*/
	struct vm_area_struct* mmap; /* 指向虚拟区间(VMA)链表 */
	struct rb_root mm_rb; /* red_black树 */
	unsigned long task_size; /*具有该结构体的进程的虚拟地址空间的⼤⼩*/
	/*...*/
	// 代码段、数据段、堆栈段、参数段及环境段的起始和结束地址。
	unsigned long start_code, end_code, start_data, end_data;
	unsigned long start_brk, brk, start_stack;
	unsigned long arg_start, arg_end, env_start, env_end;
	/*...*/
}

那既然每一个进程都会有自己独立的 mm_struct ，操作系统肯定是要将这么多进程的 mm_struct组织起来的！虚拟空间的组织方式有两种：

1. 当虚拟区较少时采取单链表，由mmap指针指向这个链表；
2. 当虚拟区间多时采取红黑树进行管理，由mm_rb指向这棵树。

linux内核使用 vm_area_struct 结构来表示一个独立的虚拟内存区域(VMA)，由于每个不同质的虚拟内存区域功能和内部机制都不同，因此一个进程使用多个vm_area_struct结构来分别表示不同类型的虚拟内存区域。上面提到的两种组织方式使用的就是vm_area_struct结构来连接各个VMA，方便进程快速访问。

进行更细致的描述，如下图所示：

虚拟内存划分原因和页表大小

5-6 为什么要有虚拟地址空间

这个问题其实可以转化为：如果程序直接可以操作物理内存会造成什么问题？

在早期的计算机中，要运行一个程序，会把这些程序全都装入内存，程序都是直接运行在内存上的，也就是说程序中访问的内存地址都是实际的物理内存地址。当计算机同时运行多个程序时，必须保证这些程序⽤到的内存总量要小于计算机实际物理内存的大小。

那当程序同时运行多个程序时，操作系统是如何为这些程序分配内存的呢？例如某台计算机总的内存大小是128M，现在同时运行两个程序A和B，A需占用内存10M，B需占用内存110。计算机在给程序分配内存时会采取这样的方法：先将内存中的前10M分配给程序A，接着再从内存中剩余的118M中划分出110M分配给程序B。

这种分配方法可以保证程序A和程序B都能运行，但是这种简单的内存分配策略问题很多。

安全风险

• 每个进程都可以访问任意的内存空间，这也就意味着任意一个进程都能够去读写系统相关内存区域，如果是⼀个木马病毒，那么他就能随意的修改内存空间，让设备直接瘫痪。

地址不确定

• 众所周知，编译完成后的程序是存放在硬盘上的，当运行的时候，需要将程序搬到内存当中去运行，如果直接使用物理地址的话，我们无法确定内存现在使用到哪里了，也就是说拷贝的实际内存地址每一次运行都是不确定的，比如：第一次执行a.out时候，内存当中一个进程都没有运行，所以搬移到内存地址是0x00000000，但是第二次的时候，内存已经有10个进程在运行了，那执行a.out的时候，内存地址就不一定了

效率低下

• 如果直接使用物理内存的话，一个进程就是作为一个整体（内存块）操作的，如果出现物理内存不够用的时候，我们一般的办法是将不常用的进程拷贝到磁盘的交换分区中，好腾出内存，但是如果是物理地址的话，就需要将整个进程一起拷走，这样，在内存和磁盘之间拷贝时间太长，效率较低。

存在这么多问题，有了虚拟地址空间和分页机制就能解决了吗？当然！

• 地址空间和页表是OS创建并维护的！是不是也就意味着，凡是想使用地址空间和页表进行映射，也一定要在OS的监管之下来进行访问！！也顺便 ，包括各个进程以及内核的相关有效数据!
• 因为有地址空间的存在和页表的映射的存在，我们的物理内存中可以对未来的数据进行任意位置的加载！物理内存的分配 和 进程的管理就可以做到没有关系，进程管理模块和内存管理模块就完成了解耦合。
  • 因为有地址空间的存在，所以我们在C、C++语言上new, malloc空间的时候，其实是在地址空间上申请的，物理内存可以甚至一个字节都不给你。⽽当你真正进行对物理地址空间访问的时候，才执行内存的相关管理算法，帮你申请内存，构建页表映射关系（延迟分配），这是由操作系统自动完成，用户包括进程完全0感知！！
• 因为页表的映射的存在，程序在物理内存中理论上就可以任意位置加载。它可以将地址空间上的虚拟地址和物理地址进行映射，在进程视角所有的内存分布都可以是有序的。

为什么要有进程地址空间

分页

作业

1. 冯诺依曼体系结构计算机的基本原理是?

A.信息存储

B.存储智能

C.数字控制

D.存储程序和程序控制

答案：D

计算机就是为了完成指定的数据处理，而通过指令按指定流程完成指定功能，指令的合集就是一段程序。

说白了计算机就是按照指定的指令执行流程完成对指定数据的处理

2. 冯诺依曼体系结构中数据输入设备的有？

A.键盘

B.显示器

C.内存

D.磁盘

答案：AD

磁盘 既可以从硬盘读取数据也可以向硬盘写入数据

3. 不属于冯诺依曼体系结构必要组成部分是：

A.CPU

B.Cache

C.RAM

D.ROM

答案：B

A.CPU 运算器与控制器

B.Cache 缓存（一种技术）

C.RAM 内存（存储器）

D.ROM 磁盘（输入输出设备）

4. 操作系统的主要功能有（）

A.控制和管理计算机系统软硬件资源

B.对汇编语言，高级语言和甚高级语言程序进行翻译

C.管理用各种语言编写的源程序

D.管理数据库文件

答案：A

• 操作系统的定位就是控制和管理计算机上软硬件资源让计算机更加好用，因此A选项是 正确的
• 对汇编语言，高级语言和甚高级语言程序进行翻译，这个功能是编译器的功能，将高级语言解释为机器指令能够被机器识别执行。因此B选项不正确，这不是操作系统的主要功能，而是一个外部应用的主要功能
• 源程序以及数据库文件都是存储在磁盘上的，这是操作系统中，文件系统管理部分的主要功能，因此C和D选项不正确。

5. 下面的函数哪个是系统调用而不是库函数()？

A.printf

B.scanf

C.fgetc

D.read

E.print_s

F.scan_s

答案：D

• 库函数是用户对系统调用接口的进一步封装接口
• printf函数是glibc中封装的用于实现格式化输出的接口
• scanf函数是glibc中封装的用于实现格式化输入的接口
• fgetc函数是glibc中封装的用于实现从输入流中获取字符的接口
• read是系统提供的用于从输入设备获取数据的接口
• print_s以及scan_s这两个函数不存在，至少在C语言的常见典型的跨平台移植代码库中不存在。

6. 下面关于系统调用的描述中,错误的是()

A.系统调用把应用程序的请求传输给系统内核执行

B.系统调用函数的执行过程应该是在用户态

C.利用系统调用能够得到操作系统提供的多种服务

D.是操作系统提供给编程人员的接口

E.系统调用给用户屏蔽了设备访问的细节

F.系统调用保护了一些只能在内核模式执行的操作指令

答案：B

• 系统调用是操作系统向上层提供的用于访问内核特定功能的接口。
• A正确，应用程序通过系统调用将自己需要完成的功能传递给内核，进行执行完成
• B错误，系统调用的运行过程是在内核态完成的，操作系统并不允许用户直接访问内核，也就是说用户运行态并不满足访问内核的权限。
• C正确，因为系统调用就是想上层提供用于完成特定内核服务或功能的。
• D正确，
• E正确，用户只需要将自己的请求以及数据通过系统调用接口传递给内核，内核中完成对应的设备访问过程，最终返回结果正确
• F正确，系统向上层提供系统调用接口用于访问内核服务或功能的很大原因也是因为这样可以最大限度的保护内核的稳定运行。

7. 系统感知进程的唯一实体是

A.进程id

B.进程控制块

C.进程管理器

D.进程名

答案：B

进程是操作系统对于程序运行过程的描述，而这个描述学名叫做进程控制块-PCB，它是操作系统操作系统管理以及调度控制程序运行的唯一实体。

根据进程的理解分析：

• A选项错误，因为进程ID只是进程的标识符，是系统能够找到特定进程的标识而已
• C选项错误，进程管理器只是对大量PCB进行管理的一个程序而已
• D选项错误，进程本质上来说没有名字，它有所调度管理运行的程序的名称，它的标识是进程ID，可以理解进程ID是它的名字
• 因此只有B选项正确，在系统角度看来，进程就是对于程序运行的描述，就是PCB进程控制块。

8. 下列有关进程的说法中，错误的是? [多选]

A.进程与程序是一一对应的

B.进程与作业是一一对应的

C.进程是静态的

D.进程是动态的过程

答案：ABC

程序是静态的指令集合，保存在程序文件中，

进程是程序的一次运行过程中的描述。

作业是用户需要计算机完成的某项任务，是要求计算机所做工作的集合。

根据以上概念理解：

A选项错误，因为一个程序可以同时运行多次，也就有了多个进程

B选项错误，因为一个作业任务的完成可由多个进程组成，且必须至少由一个进程组成

C选项错误，因为程序是静态的，而进程是动态的。

D选项正确

9. 在抢占式多任务处理中，进程被抢占时，哪些运行环境需要被保存下来？[多选]

A.所有cpu寄存器的内容

B.全局变量

C.页表指针

D.程序计数器

答案：ACD

A. 所有cpu寄存器的内容 cpu上正在处理的数据

B. 全局变量 程序内的数据（并不一定正在被处理）

C. 页表指针 程序切换时会将页表起始地址加载到寄存器中

D. 程序计数器 下一步程序要执行的指令地址

10. 关于 linux 的进程，下面说法不正确的是：

A.僵尸进程会被 init 进程接管，不会造成资源浪费；

B.孤儿进程的父进程在它之前退出，会被 init 进程接管，不会造成资源浪费；

C.进程是资源管理的最小单位，而线程是程序执行的最小单位。Linux 下的线程本质上用进程实现

D.子进程如果对资源只是进行读操作，那么完全和父进程共享物理地址空间。

答案：A

A. 僵尸进程指的是进程退出后不会完全释放资源，会造成系统资源泄漏；

B. 孤儿进程在父进程退出后，父进程成为init进程，进程退出，孤儿进程的资源将被init进程释放

C. 操作系统通过pcb实现对程序运行调度控制

D. fork系统调用通过复制父进程创建一个子进程，父子进程数据独有，代码共享（在数据不发生改变的情况下父子进程资源指向同一块物理内存空间（调研写时拷贝技术））

11. 关于僵尸进程，以下描述正确的有？

A.僵尸进程必须使用waitpid/wait接口进行等待

B.僵尸进程最终会自动退出

C.僵尸进程可以被kill命令杀死

D.僵尸进程是因为父进程先于子进程退出而产生的

答案：A

僵尸进程是指先于父进程退出的子进程程序已经不再运行，但是因为需要保存退出原因，因此资源没有完全释放的进程，

它不会自动退出释放所有资源，也不会被kill命令再次杀死

僵尸进程会产生资源泄露，需要避免

避免僵尸进程的产生采用进程等待(wait/waitpid)方式完成

根据以上理解分析：

A选项正确，僵尸进程会造成资源泄露，必须使用wait/waitpid接口进行等待处理

B选项错误，僵尸进程不会完全释放资源退出

C选项错误，僵尸进程是已经退出运行的进程，无法被杀死

D选项错误，僵尸进程是子进程先于父进程退出。

12. 下面有关孤儿进程和僵尸进程的描述，说法错误的是？

A.孤儿进程：一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。

B.僵尸进程：一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程。

C.孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。

D.孤儿进程和僵尸进程都可能使系统不能产生新的进程，都应该避免

答案：D

根据答案选项理解正确描述

僵尸进程：子进程先于父进程退出，父进程没有对子进程的退出进行处理，因此子进程会保存自己的退出信息而无法释放所有资源成为僵尸进程导致资源泄露。

孤儿进程：父进程先于子进程退出，子进程成为孤儿进程，运行在后台，父进程成为1号进程（而孤儿进程的退出，会被1号进程负责任的进行处理，因此不会成为僵尸进程）

根据以上对两种特殊进程的理解分析选项：

A选项正确，父进程退出后，所有子进程都会成为孤儿进程；

B选项正确，僵尸进程的产生就是因为父进程没有对子进程的退出进行处理，因此子进程无法完全释放资源

C选项正确，子进程成为孤儿进程后被1号进程收养，并且他们的退出状态由1号进程完成处理

D选项错误，僵尸进程的产生会造成资源泄露需要避免，但是孤儿进程的产生一般都是具有目的性的，并且退出后并不会成为僵尸进程，因此无需特殊处理。

13. 以下描述错误的有

作业内容

A.守护进程：运行在后台的一种特殊进程，独立于控制终端并周期性地执行某些任务。

B.僵尸进程：一个进程 fork 子进程，子进程退出，而父进程没有 `wait`/`waitpid`子进程，那么子进程的进程描述符仍保存在系统中，这样的进程称为僵尸进程。

C.孤儿进程：一个父进程退出，而它的一个或多个子进程还在运行，这些子进程称为孤儿进程。（孤儿进程将由 init 进程收养并对它们完成状态收集工作）

D.精灵进程：精灵进程退出后会成为僵尸进程

答案：D

僵尸进程：子进程先于父进程退出，父进程没有对子进程的退出进行处理，因此子进程会保存自己的退出信息而无法释放所有资源成为僵尸进程导致资源泄露。

孤儿进程：父进程先于子进程退出，子进程成为孤儿进程，运行在后台，父进程成为1号进程（而孤儿进程的退出，会被1号进程负责任的进行处理，因此不会成为僵尸进程）

守护进程&精灵进程：这两种是同一种进程的不同翻译，是特殊的孤儿进程，不但运行在后台，最主要的是脱离了与终端和登录会话的所有联系，也就是默默的运行在后台不想受到任何影响

根据以上理解分析：

D错误：精灵进程其实和守护进程是一样的，不同的翻译叫法而已，它的父进程是1号进程，退出后不会成为僵尸进程

14. 请问孤儿进程会被以下哪一个系统进程接管？

A.syslogd

B.init

C.sshd

D.vhand

答案：B

孤儿进程：子进程先于父进程退出，运行在后台，父进程成为1号init进程（在centos7中1号进程改名为systemd进程），退出后由1号进程回收资源

syslogd：系统中的日志服务进程

init：init进程是内核启动的第一个用户级进程，用于完成处理孤儿进程以及其他的一些重要任务。

sshd：远程登录服务进程

vhand：内存置换服务进程

15. 以下关于孤儿进程的描述正确的有

A.父进程先于子进程退出，则子进程成为孤儿进程

B.孤儿进程会产生资源泄漏

C.孤儿进程运行在系统后台

D.孤儿进程没有父进程

答案：AC

孤儿进程：子进程先于父进程退出，运行在后台，父进程成为1号进程，退出后由1号进程回收资源，因此不会成为僵尸进程，而是直接释放所有资源

孤儿进程的产生一般都会带有目的性，比如我们需要一个程序运行在后台，或者我们不想一个进程退出后成为僵尸进程之类的需要

根据以上理解分析：

A选项正确：父进程先于子进程退出，子进程就会成为孤儿进程

B选项错误：孤儿进程退出不会成为僵尸进程，因此也不会资源泄露

C选项正确：孤儿进程是运行在后台的

D选项错误：福尔进程也有父进程，父进程是1号进程

16. 以下描述正确的有 [多选]

A.子进程默认会复制拥有与父进程相同的环境变量

B.环境变量使shell运行环境配置变的更加复杂

C.环境变量可以使用export命令设置

D.删除一个环境变量可以使用unset和rm命令

答案：AC

A和C选项正确，根据选项理解功能即可。

B选项错误 环境变量设置之后，不需要重启shell，也不需要重新加载文件，只要设置换环境变量就能直接生效，因此可以使运行环境的配置更加灵活简单

D选项错误 rm只是普通的文件操作指令，无法删除环境变量

17. 以下哪些命令可以查看环境变量 [多选]

A.echo

B.env

C.set

D.export

答案：ABC

echo 用于输出打印一个变量的内容，包括环境变量

env 用于打印所有环境变量信息

set 用于输出打印所有环境配置以及变量信息，不限于环境变量

export用于设置环境变量

根据题意，选择D，因为D并不是用于查看环境变量的操作。

18. 使用shell时，默认的环境变量放在哪里？

A.~/.bash_profile

B.~/.bash

C./etc/profile.d

D.~/bash

答案：A

• ~/.bash_profile：用户级的环境配置文件，每个用户目录下都会具有各自的，在用户每次登录系统时被读取，里面所有命令都会被shell执行。包括环境变量的配置命令，因此A正确
• ~/.bash 以及 ~/bash 在linux的用户目录中默认是没有这两个文件的，因此也就不清楚其作用了，因此B和D都是错误的
• /etc/progile.d 这是个目录或者说文件夹，其中包含了系统级的环境配置文件，任意用户登录时都会执行这个目录下的环境配置文件完成环境配置，但是要注意这个是目录并不是保存环境变量配置的配置文件，因此D错误

19. 一个分页存储管理系统中，地址长度为 32 位，其中页号占 8 位，则页表长度是__。

A.2的8次方

B.2的16次方

C.2的24次方

D.2的32次方

答案：A

页号即页表项的序号，总共占8个二进制位，意味着页表项的个数就是2^8

20. p和"hello,world"存储在内存哪个区域？

int main() {
	char* p = "hello,world";
	return 0;
}

A.栈，堆

B.栈，栈

C.堆，只读存储区

D.栈，只读存储区

答案：D

p是一个局部指针变量，本身空间在栈中，

而空间中存储的地址指向的是一块常量字符串的地址，常量字符串存储在只读存储区

21. 在CPU和物理内存之间进行地址转换时，（ ）将地址从虚拟（逻辑）地址空间映射到物理地址空间

A.TCB

B.MMU

C.CACHE

D.DMA

答案：B

A. TCB 线程控制块

B. 内存管理单元, 一种负责处理中央处理器（CPU）的内存访问请求, 功能包括虚拟地址到物理地址的转换（即虚拟内存管理）、内存保护、中央处理器高速缓存的控制

C. CACHE 高速缓存

D. DMA 直接内存存取