系统性学习Linux-第三讲-进程概念

微露清风2026-02-03 9:13

系统性学习Linux-第三讲-进程概念

  • [1. 冯 · 诺依曼体系结构](#1. 冯 · 诺依曼体系结构)
  • [2. 操作系统(Operator System)](#2. 操作系统(Operator System))
    • [2.1 概念](#2.1 概念)
    • [2.2 设计OS的目的](#2.2 设计OS的目的)
    • [2.3 核心功能](#2.3 核心功能)
    • [2.4 如何理解 "管理"](#2.4 如何理解 "管理")
    • [2.5 系统调用和库函数概念](#2.5 系统调用和库函数概念)
  • [3. 进程](#3. 进程)
    • [3.1 基本概念与基本操作](#3.1 基本概念与基本操作)
      • [3.1.2 描述进程 - PCB](#3.1.2 描述进程 - PCB)
      • [3.2.3 ` task_struct `](#3.2.3 task_struct)
      • [3.1.4 查看进程](#3.1.4 查看进程)
      • [3.1.5 通过系统调用获取进程标识符](#3.1.5 通过系统调用获取进程标识符)
      • [3.1.6 通过系统调用创建进程 - ` fork ` 初识](#3.1.6 通过系统调用创建进程 - fork 初识)
    • [3.2 进程状态](#3.2 进程状态)
      • [3.2.1 Linux 内核源代码怎么说](#3.2.1 Linux 内核源代码怎么说)
      • [3.2.2 进程状态查看](#3.2.2 进程状态查看)
      • [3.2.3 Z(zombie) - 僵尸进程](#3.2.3 Z(zombie) - 僵尸进程)
      • [3.2.4 僵尸进程危害](#3.2.4 僵尸进程危害)
      • [3.2.5 孤儿进程](#3.2.5 孤儿进程)
    • [3.3 进程优先级](#3.3 进程优先级)
      • [3.3.1 基本概念](#3.3.1 基本概念)
      • [3.3.2 查看系统进程](#3.3.2 查看系统进程)
      • [3.3.3 ` PRI ` && ` NI `](#3.3.3 PRI && NI)
      • [3.3.4 ` PRI ` vs ` NI `](#3.3.4 PRI vs NI)
      • 3-3-5查看进程优先级的命令
      • [3.3.6 补充概念 - 竞争、独立、并行、并发](#3.3.6 补充概念 - 竞争、独立、并行、并发)
    • [3.4 进程切换](#3.4 进程切换)
    • [3.4 Linux 2.6 内核进程 O(1) 调度队列](#3.4 Linux 2.6 内核进程 O(1) 调度队列)
      • [3.4.1 一个 ` CPU ` 拥有⼀个 ` runqueue `](#3.4.1 一个 CPU 拥有⼀个 runqueue)
      • [3.4.2 优先级](#3.4.2 优先级)
      • [3.4.3 活动队列](#3.4.3 活动队列)
      • [3.4.4 过期队列](#3.4.4 过期队列)
      • [3.4.5 ` active ` 指针和 ` expired ` 指针](#3.4.5 active 指针和 expired 指针)
      • [3.4.6 总结](#3.4.6 总结)
  • [4. 命令行参数和环境变量](#4. 命令行参数和环境变量)
    • [4.1 基本概念](#4.1 基本概念)
    • [4.2 常见环境变量](#4.2 常见环境变量)
    • [4.3 查看环境变量方法](#4.3 查看环境变量方法)
    • [4.4 和环境变量相关的命令](#4.4 和环境变量相关的命令)
    • [4.5 环境变量的组织方式](#4.5 环境变量的组织方式)
    • [4.6 通过代码如何获取环境变量](#4.6 通过代码如何获取环境变量)
    • [4.7 通过系统调用获取或设置环境变量](#4.7 通过系统调用获取或设置环境变量)
    • [4.8 环境变量通常是具有全局属性的](#4.8 环境变量通常是具有全局属性的)
  • [5. 程序地址空间](#5. 程序地址空间)
    • [5.1 研究平台](#5.1 研究平台)
    • [5.2 程序地址空间](#5.2 程序地址空间)
    • [5.3 虚拟地址](#5.3 虚拟地址)
    • [5.4 进程地址空间](#5.4 进程地址空间)
    • [5.5 虚拟内存管理](#5.5 虚拟内存管理)
    • [5.6 为什么要有虚拟地址空间](#5.6 为什么要有虚拟地址空间)

本讲重点：

  • 认识冯诺依曼系统

  • 操作系统概念与定位，理解"管理"

  • 深⼊理解进程概念，了解 PCB

  • 学习进程状态，学会创建进程，掌握僵尸进程和孤儿进程，及其形成原因和危害

  • 了解进程调度，Linux 进程优先级，理解进程竞争性与独立性，理解并行与并发

  • 理解进程切换，以及 Linux2.6 kernel，O(1) 调度算法架构

  • 理解环境变量，熟悉常见环境变量及相关指令，getenv / setenv 函数

  • 理解 C 内存空间分配规律，了解进程内存映像和应用程序区别，认识虚拟地址空间。

1. 冯 · 诺依曼体系结构

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

截止目前，我们所认识的计算机，都是由⼀个个的硬件组件组成

  • 输入单元：包括键盘，鼠标，扫描仪，写板等

  • 中央处理器(CPU)：含有运算器和控制器等

  • 输出单元：显示器，打印机等

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

  • 这里的存储器指的是内存

  • 不考虑缓存情况，这里的 CPU 能且只能对内存进行读写，不能访问外设（输入或输出设备）(数据层面)

  • 外设（输入或输出设备）要输入或者输出数据，也只能写入内存或者从内存中读取。

  • ⼀句话，所有设备都只能直接和内存打交道。

下面讲解一下 冯 · 诺依曼 体系为何具有划时代的意义：

冯・诺依曼体系的划时代意义在于，它打破了早期计算机专用化、靠物理接线编程的局限，以存储程序、二进制编码、

五大硬件模块化为核心原则，首次实现程序与数据统一存储、软件与硬件分离，为现代通用计算机奠定了标准化、可扩展、可落地

的设计框架，让计算机从实验室的专用计算原型升级为可灵活编程、量产普及的通用信息处理设备；

这一架构不仅催生了独立的软件产业，成为此后大型机、PC、手机等几乎所有通用计算设备的设计基石，推动了数字信息时代的到来，

其核心设计原则至今仍被遵循，后续的架构优化也均以其为基础而非颠覆。

2. 操作系统(Operator System)

2.1 概念

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

  • 内核（进程管理，内存管理，文件管理，驱动管理）

  • 其他程序（例如函数库、shell程序 、等等...）

2.2 设计OS的目的

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

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

2.3 核心功能

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

2.4 如何理解 "管理"

对于操作系统如何对软硬件交互，管理所有的资源，我们引入一个例子，我们将操作系统比作一位学校的校长，

我们讲所有的软硬件比作学生，在学校中，校长对所有学生进行管理时，肯定不能面面俱到地像父母一样贴身 24 小时，

对学生进行看护，他只需要向学校中的 "辅导员" 获取学生的信息，辅导员就是我们的系统调用接口，用来获取软硬件信息，

收集到学生信息后进行管理即可，比如得知哪位学生的成绩不合格，是否要降级，或者开除，所以对于被管理者-学生，

我们要对其的信息进行具体的描述 ，当有多个学生信息的时候，我们就要把所有信息组织起来。所以，对于被管理者，

我们要先描述，后组织，那么我们如何进行组织呢，我们将学生的单个信息放入链表节点中，用单链表的数据结构进行管理-增删改查。

总结：

计算机管理硬件

  1. 描述起来，用 struct 结构体

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

2.5 系统调用和库函数概念

  • 在开发角度，操作系统对外会表现为⼀个整体，但是会暴露自己的部分接口，供上层开发使用，这部分由操作系统提供的接口，叫做系统调用。

  • 系统调用在使用上，功能比较基础，对用户的要求相对也比较高，所以，有心的开发者可以对部分系统调用进行适度封装，从而形成库，有了库，就很有利于更上层用户或者开发者进行⼆次开发。

那么现在，我们就可以进行推断，操作系统是怎么管理进行进程管理的呢？

很简单，先把进程描述起来，再把进程组织起来！

3. 进程

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.2.3 task_struct

内容分类

  • 标识符：描述本进程的唯一标识符，用来区别其他进程。

  • 状态：任务状态，退出代码，退出信号等。

  • 优先级：相对于其他进程的优先级。

  • 程序计数器：程序中即将被执行的下一条指令的地址。

  • 内存指针：包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块的指针

  • 上下文数据：进程执行时处理器的寄存器中的数据。

  • I / O状态信息：包括显示的 I / O 请求，分配给进程的 I / O 设备和被进程使用的文件列表。

  • 记账信息：可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号等。

  • 其他信息

  • 具体详细信息后续会介绍

组织进程

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

3.1.4 查看进程

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

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

  1. 大多数进程信息同样可以使用 top 和 ps 这些用户级工具来获取
c 复制代码 
#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）

c 复制代码 
#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 有两个返回值

  • 父子进程代码共享，数据各自开辟空间，私有⼀份（采用写时拷贝）

c 复制代码 
#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 进行分流
c 复制代码 
#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 的难点进行讲解：

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

我们可以在 man 手册中看到对于 fork 函数返回值的描述， 对于我们之前学习的函数，我们进行 return 操作时只会返回一个数据，

这里明确表明对于父进程与子进程，返回了不同的值，这里我们就要对 fork 函数进行深度解析，当父进程对 fork 函数进行调用时，

进入函数后，创建了子进程，子进程由两部分构成，task_struct ，与它的代码与数据，前者在 fork 函数内由系统创建，

但是此时我们发现一个问题，就是子进程没有对应的代码与数据，这时系统就会让它与父进程共享代码与数据，

所以这时，父进程与子进程各有一份代码与数据，父进程执行父进程的 return 语句，子进程执行子进程的 return 语句。

这就是为什么会产生两个返回值的原因。

2. 为什么一份代码中，会有两个循环在一直执行

在对于为什么会有两个返回值的原因理解后，由于父进程与子进程各存储了一份代码与数据，所以根据返回值的不同，

就是跳转到各自符合条件的代码块进行运行，本质上已经是两个程序在运行，而不是一个程序在运行两个循环。

3.2 进程状态

3.2.1 Linux 内核源代码怎么说

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

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

c 复制代码 
/*
*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）：这个状态只是⼀个返回状态，你不会在任务列表里看到这个状态。

3.2.2 进程状态查看

bash 复制代码 
ps aux / ps axj 命令

  • a：显示一个终端所有的进程，包括其他用户的进程。

  • x：显示没有控制终端的进程，例如后台运行的守护进程。

  • j：显示进程归属的进程组 ID 、会话 ID 、父进程 ID ，以及与作业控制相关的信息。

  • u：以用户为中心的格式显示进程信息，提供进程的详细信息，如用户、CPU 和内存使用情况等

3.2.3 Z(zombie) - 僵尸进程

  • 僵尸状态（Zombies）是⼀个比较特殊的状态。当进程退出并且父进程（使用 wait() 系统调用，后面讲）没有读取到子进程退出的返回代码时就会产生僵尸进程。

  • 僵尸进程会以终止状态保持在进程表中，并且会一直在等待父进程读取退出状态代码。

  • 所以，只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入 Z 状态来一个创建维持 30 秒的僵死进程例子：

c 复制代码 
#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状态 之后，那该如何处理呢？

  • 父进程先退出，子进程就称之为 "孤儿进程"

  • 孤儿进程被 PID 为 1 的 init / systemd 进程领养，当程序结束后由 init / systemd 进程进行回收。

c 复制代码 
#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 && 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

系统函数：

c 复制代码 
#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 下采用进程切换的方式，在一段时间之内，让多个进程都得以推进，称之为并发

3.4 进程切换

CPU 上下文切换：其实际含义是任务切换，或者 CPU 寄存器切换。当多任务内核决定运行另外的任务时，

它保存正在运行任务的当前状态，也就是 CPU 寄存器中的全部内容。这些内容被保存在任务自己的堆栈中,

入栈工作完成后就把下一个将要运行的任务的当前状况从该任务的栈中重新装入 CPU 寄存器，并开始下一个任务的运行，

这一过程就是 context switch 。

参考一下 Linux 内核 0.11 代码：

❗️注意：

时间片：当代计算机都是分时操作系统，没有进程都有它合适的时间片（其实就是一个计数器）。时间片到达，进程就被操作系统从 CPU 中剥离下来。

3.4 Linux 2.6 内核进程 O(1) 调度队列

上图是 Linux 2.6 内核中进程队列的数据结构，之间关系也已经给大家画出来，方便大家理解

3.4.1 一个 CPU 拥有⼀个 runqueue

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

3.4.2 优先级

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

  • 实时优先级：0 ~ 99（不关心）

3.4.3 活动队列

  • 时间片还没有结束的所有进程都按照优先级放在该队列

  • nr_active ：总共有多少个运行状态的进程

  • queue[140] ：一个元素就是一个进程队列，相同优先级的进程按照 FIFO （First in First Out） 规则进行排队调度，所以，数组下标就是优先级！

从该结构中，选择⼀个最合适的进程，过程是怎么的呢？

  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) 算法！
c 复制代码 
struct rq {
 	spinlock_t lock;
 	
 	/*
 	* nr_running and cpu_load should be in the same cacheline because
 	* remote CPUs use both these fields when doing load calculation.
 	*/
 	
 	unsigned long nr_running;
 	unsigned long raw_weighted_load;
#ifdef CONFIG_SMP
 		unsigned long cpu_load[3];
#endif
 	unsigned long long nr_switches;

	/*
 	* This is part of a global counter where only the total sum
 	* over all CPUs matters. A task can increase this counter on
 	* one CPU and if it got migrated afterwards it may decrease
 	* it on another CPU. Always updated under the runqueue lock:
 	*/
 	unsigned long nr_uninterruptible;
 	
 	unsigned long expired_timestamp;
 	unsigned long long timestamp_last_tick;
 	struct task_struct *curr, *idle;
 	struct mm_struct *prev_mm;
	struct prio_array *active, *expired, arrays[2];
 	int best_expired_prio;
 	atomic_t nr_iowait;

#ifdef CONFIG_SMP
 	struct sched_domain *sd;
 	/* For active balancing */
 	int active_balance;
 	int push_cpu;
 	struct task_struct *migration_thread;
 	struct list_head migration_queue;
#endif

#ifdef CONFIG_SCHEDSTATS
 	/* latency stats */
 	struct sched_info rq_sched_info;
 	/* sys_sched_yield() stats */
 
 	unsigned long yld_exp_empty;
 	unsigned long yld_act_empty;
 	unsigned long yld_both_empty;
 	unsigned long yld_cnt;
 	/* schedule() stats */
 
 	unsigned long sched_switch;
 	unsigned long sched_cnt;
 	unsigned long sched_goidle;
 
 	/* try_to_wake_up() stats */
 	unsigned long ttwu_cnt;
 	unsigned long ttwu_local;
#endif
 
 	struct lock_class_key rq_lock_key;
};

/*
 * These are the runqueue data structures:
 */

struct prio_array {
 	unsigned int nr_active;
 	DECLARE_BITMAP(bitmap, MAX_PRIO+1); /* include 1 bit for delimiter */
 	struct list_head queue[MAX_PRIO];
};

4. 命令行参数和环境变量

4.1 基本概念

  • 环境变量（environment variables）一般是指在操作系统中用来指定操作系统运行环境的一些参数

  • 如：我们在编写 C/C++ 代码的时候，在链接的时候，从来不知道我们的所链接的动态静态库在哪里，但是照样可以链接成功，生成可执行程序，原因就是有相关环境变量帮助编译器进行查找。

  • 环境变量通常具有某些特殊用途，还有在系统当中通常具有全局特性

4.2 常见环境变量

  • PATH：指定命令的搜索路径

  • HOME：指定用户的主工作目录（即用户登陆到 Linux 系统中时，默认的目录）

  • SHELL：当前 Shell ，它的值通常是 /bin/bash 。

4.3 查看环境变量方法

bash 复制代码 
echo $NAME #NAME:你的环境变量名称

测试 PATH

  1. 创建 hello.c 文件
c 复制代码 
#include <stdio.h>
 
int main()
{
 	printf("hello world!\n");
 	return 0;
}

  1. 对比 ./hello 执行和直接 hello 执行

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

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

  4. 对比测试

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

测试 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 通过代码如何获取环境变量

  • 命令行第三个参数
c 复制代码 
#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 获取
c 复制代码 
#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 通过系统调用获取或设置环境变量

  • putenv ，往后文章会进行详细讲解

  • getenv ，下面我们进行详细讲解

c 复制代码 
#include <stdio.h>
#include <stdlib.h>
int main()
{
 	printf("%s\n", getenv("PATH"));
 	return 0;
}

常用 getenv 和 putenv 函数来访问特定的环境变量。

4.8 环境变量通常是具有全局属性的

  • 环境变量通常具有全局属性，可以被子进程继承下去
c 复制代码 
#include <stdio.h>
#include <stdlib.h>
int main()
{
 	char *env = getenv("MYENV");
 	
 	if(env){
 		printf("%s\n", env);
 	}
 	
 	return 0;
}

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

  • 导出环境变量 export MYENV="hello world"

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

5. 程序地址空间

又称虚拟内存空间，或者虚拟地址

5.1 研究平台

  • kernel 2.6.32

  • 32 位平台

5.2 程序地址空间

在讲 C 语言的时候，读者们都大概见过这样一个空间布局图

可是我们对他并不理解！但在这里我们先对这个图的各个区域分布验证：

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;
}

输出结果：

c 复制代码 
$ ./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
env[6]: 0x7ffd0f9a4892
env[7]: 0x7ffd0f9a48a5
env[8]: 0x7ffd0f9a48ae
env[9]: 0x7ffd0f9a48f1
env[10]: 0x7ffd0f9a4e8d
env[11]: 0x7ffd0f9a4ea6
env[12]: 0x7ffd0f9a4f00
env[13]: 0x7ffd0f9a4f13
env[14]: 0x7ffd0f9a4f24
env[15]: 0x7ffd0f9a4f3b
env[16]: 0x7ffd0f9a4f43
env[17]: 0x7ffd0f9a4f52
env[18]: 0x7ffd0f9a4f5e
env[19]: 0x7ffd0f9a4f93
env[20]: 0x7ffd0f9a4fb6
env[21]: 0x7ffd0f9a4fd5
env[22]: 0x7ffd0f9a4fdf

5.3 虚拟地址

我们先通过代码感受⼀下

c 复制代码 
#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;
}

输出：

c 复制代码 
//与环境相关，观察现象即可 
parent[2995]: 0 : 0x80497d8
child[2996]: 0 : 0x80497d8

我们发现，输出出来的变量值和地址是⼀模⼀样的，是因为子进程按照父进程为模版，父子并没有对变量进行任何修改。

所以此时父子进程共享一份代码与数据，可是将代码稍加改动:

c 复制代码 
#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;
}

输出结果：

c 复制代码 
//与环境相关，观察现象即可 
child[3046]: 100 : 0x80497e8
parent[3045]: 0 : 0x80497e8

我们发现，父子进程，输出地址是⼀致的，但是变量内容不一样！

能得出如下结论:

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

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

  • 在 Linux 地址下，这种地址叫做虚拟地址

  • 我们在用 C/C++ 语言所看到的地址，全部都是虚拟地址！物理地址，用户⼀概看不到，由 OS 统⼀管理，OS 必须负责将虚拟地址 转化成物理地址。

5.4 进程地址空间

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

看图：

分页&虚拟地址空间

说明:

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

5.5 虚拟内存管理

描述 linux 下进程的地址空间的所有的信息的结构体是 mm_struct （内存描述符）。每个进程只有⼀个 mm_struct 结构，

在每个进程的 task_struct 结构中，有⼀个指向该进程的 mm_struct 结构体指针。

c 复制代码 
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

c 复制代码 
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 ，方便进程快速访问。

c 复制代码 
struct vm_area_struct {
 	unsigned long vm_start; //虚存区起始 
 	unsigned long vm_end; //虚存区结束 
 	struct vm_area_struct *vm_next, *vm_prev; //前后指针 
 	struct rb_node vm_rb; //红⿊树中的位置 
 	unsigned long rb_subtree_gap;
 	struct mm_struct *vm_mm; //所属的 mm_struct 
 	pgprot_t vm_page_prot; 
 	unsigned long vm_flags; //标志位 
 	struct {
 		struct rb_node rb;
 		unsigned long rb_subtree_last;
 	} shared; 
 	struct list_head anon_vma_chain;
 	struct anon_vma *anon_vma;
 	const struct vm_operations_struct *vm_ops; //vma对应的实际操作 
 	unsigned long vm_pgoff; //⽂件映射偏移量 
 	struct file * vm_file; //映射的⽂件 
 	void * vm_private_data; //私有数据 
 	atomic_long_t swap_readahead_info;
#ifndef CONFIG_MMU
 	struct vm_region *vm_region; /* NOMMU mapping region */
#endif
#ifdef CONFIG_NUMA
 	struct mempolicy *vm_policy; /* NUMA policy for the VMA */
#endif
 	struct vm_userfaultfd_ctx vm_userfaultfd_ctx;
} __randomize_layout;

所以我们可以对上图在进行更细致的描述，如下图所示：


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 感知！！

  • 因为页表的映射的存在，程序在物理内存中理论上就可以任意位置加载。它可以将地址空间上的虚拟地址和物理地址进行映射，在进程视角所有的内存分布都可以是有序的。

相关推荐
AOwhisky9 分钟前
Kubernetes 学习笔记：集群管理、命名空间与 Pod 基础
linux·运维·笔记·学习·云原生·kubernetes
光影少年1 小时前
大屏页面，一次多个请求，请求加密导致 点击 全局时间选择器 时出现卡顿咋解决（面板收起会延迟1~2秒）
前端·javascript·vue.js·学习·前端框架·echarts·reactjs
小龙在慢慢变强..1 小时前
目录结构（FHS 标准）
linux·运维·服务器
2035去旅行1 小时前
嵌入式开发，如何选择C标准库
linux·arm开发
刘延林.1 小时前
win11系统下通过 WSL2 安装Ubuntu 24.04 使用RTX 5080 GPU
linux·运维·ubuntu
星恒讯工业路由器1 小时前
星恒讯工业生产自动化解决方案
运维·物联网·自动化·智能路由器·信息与通信
a8a3021 小时前
Laravel9.x新特性全解析
运维·spring boot·nginx
beyond阿亮1 小时前
IEC104 Client Simulator - IEC104 主站/客户端模拟器 仿真器免费使用教程
运维·服务器·网络
sakiko_2 小时前
UIKit学习笔记2-组件嵌套、滚动视图等
笔记·学习·objective-c·swift·uikit
知识分享小能手2 小时前
R语言入门学习教程，从入门到精通，R语言类别比较数据可视化- 完整知识点与案例代码(4）
学习·信息可视化·r语言
热门推荐
01GitHub 镜像站点02近期有什么ai的新消息，新动态？ 2026.4月03Codex 接入 DeepSeek API 完整配置文档042026年4月AI大事件深度解读：大模型竞争进入“深水区“052026年AI编程工具终极横评：Cursor vs Claude Code vs Copilot06【AI】2026 年具身智能模型和世界模型总结07在Windows 11上安装Docker的踩坑记录08零基础教你claude code 接入 deepseek V409VSCode + Copilot下：配置并使用 DeepSeek102026年AI前瞻：量子AI、具身智能与科学发现的新纪元