当前位置： 首页 > news >正文

Linux：4_进程概念

news 2025/8/24 13:30:33

进程概念

一.冯诺依曼体系结构

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

image-20250716163233580

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

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

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

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

image-20250716163348640

二.操作系统(Operator System)

1. 概念

操作系统是⼀款进⾏软硬件管理的软件

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

  • 内核（进程管理，内存管理，⽂件管理，驱动管理）–侠义
  • 其他程序（例如函数库，shell程序等等）–⼴义还包括

在这里插入图片描述

2. 设计OS的⽬的

  • 对下，与硬件交互，管理所有的软硬件资源
  • 对上，为⽤⼾程序（应⽤程序）提供⼀个良好的执⾏环境

image-20250716163622495

image-20250716163737861

3. 核⼼功能

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

4. 如何理解 “管理”

  • 管理的例⼦ - 学⽣，辅导员，校⻓
  • 描述被管理对象
  • 组织被管理对象
    在这里插入图片描述

总结：先描述，再组织

计算机管理硬件

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

5. 系统调⽤和库函数概念

操作系统要向上提供对应的服务，但操作系统不相信任何⽤户或者⼈.

image-20250716164130628

  • 在开发⻆度，操作系统对外会表现为⼀个整体，但是会暴露⾃⼰的部分接⼝，供上层开发使⽤，这部分由操作系统提供的接⼝，叫做系统调⽤。

  • 系统调⽤在使⽤上，功能⽐较基础，对⽤⼾的要求相对也⽐较⾼，所以，有⼼的开发者可以对部分系统调⽤进⾏适度封装，从⽽形成库，有了库，就很有利于更上层⽤⼾或者开发者进⾏⼆次开发。

  • 库函数和系统调⽤属于上下层关系。

承上启下

那在还没有学习进程之前，就问⼤家，操作系统是怎么管理进⾏进程管理的呢？很简单，先把进程描述起来，再把进程组织起来！

三.进程

1. 基本概念与基本操作

image-20250716164422869

(1).概念
  • 课本概念：程序的⼀个执⾏实例，正在执⾏的程序等
  • 内核观点：担当分配系统资源（CPU时间，内存）的实体。
(2).描述进程-PCB(进程控制块)

基本概念

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

task_struct-PCB的⼀种

  • 在Linux中描述进程的结构体叫做task_struct。(任务结构体)

  • task_struct是Linux内核的⼀种数据结构，它会被装载到RAM(内存)⾥并且包含着进程的信息。

(3).task_ struct

进程的所有属性，都可以直接或者间接通过task_struct 找到.

内容分类：

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

组织进程：

对进程的管理，变成了对链表的增删查改.

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

image-20250716165735301

(4).查看进程
  1. 进程的信息可以通过 /proc 系统⽂件夹查看

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

/proc ⽬录是⼀个内存⽂件系统，并不是存在于磁盘上的真实⽂件。(内存⽂件系统指整个⽂件系统是在内存中创建的)

image-20250716170438215

  1. ⼤多数进程信息同样可以使⽤top和ps这些⽤⼾级⼯具来获取

image-20250716181058518

(5).通过系统调⽤获取进程标⽰符
  • 进程id（PID）
  • ⽗进程id（PPID）

Linux所有的进程都是被它的⽗进程所创建的｡

image-20250716181235085

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

image-20250716181719457

  • 杀死进程：kill -9 PID或者ctrl+c
(6).通过系统调⽤创建进程-fork初识
  • 运⾏ man fork 认识fork

image-20250716211854853

  • fork有两个返回值:创建⼦进程成功，⼦进程PID给⽗进程，0给⼦进程；⼦进程创建失败，返回-1。

  • ⽗⼦进程代码共享，数据各⾃开辟空间，私有⼀份（采⽤写时拷⻉）;⽗⼦进程的代码是共享的,因为它们对于代码都是只读的;⽗⼦进程间先互相不影响;写时拷⻉:把⽗⼦任何⼀⽅，进⾏修改数据，OS把被修改的数据在底层拷⻉⼀份，让⽬标进程修改这个拷⻉!

    image-20250716212238789

image-20250804223812568

  • fork 之后通常要⽤ if 进⾏分流

image-20250804224008320

2. 进程状态(就是task_struct里面的一个整型变量)

(1).Linux内核源代码怎么说

  • ⼀个task_struct既存在于⼀个全局的双链表，⼜存在于调度队列中。⼀个CPU有⼀个调度队列。

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

    下⾯的状态在kernel源代码⾥定义：

image-20250807151303351

image-20250807151326678

image-20250804225309749

image-20250807151402115

image-20250804225918050

image-20250807151557605

image-20250807151608297

(2).进程状态查看
ps aux / ps axj 命令

  • a：显⽰⼀个终端所有的进程，包括其他⽤⼾的进程。

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

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

  • u：以⽤⼾为中⼼的格式显⽰进程信息，提供进程的详细信息，如⽤⼾、CPU和内存使⽤情况等

  • l：显示详细信息(包含优先级、Nice 值等)

image-20250807152719622

(3).Z(zombie)-僵⼫进程
  • 僵死状态（Zombies）是⼀个⽐较特殊的状态。当进程退出并且⽗进程（使⽤wait()系统调⽤,后⾯讲）没有读取到⼦进程退出的返回代码时就会产⽣僵死(⼫)进程
  • 僵死进程会以终⽌状态保持在进程表中，并且会⼀直在等待⽗进程读取退出状态代码。
  • 所以，只要⼦进程退出，⽗进程还在运⾏，但⽗进程没有读取⼦进程状态，⼦进程进⼊Z状态
  • ⼀个进程退出时操作系统可以把⼀个进程的代码和数据释放掉，因为这个进程不会被调度了；但是PCB信息不能释放，要等⽗进程读取完⼦进程退出的返回代码后才能释放.
  • 我们创建⼦进程的⽬的，是为了让⼦进程完成某种事情的；结果相关的信息，⽗进程得知道
#include <stdio.h>
#include <stdlib.h>
int main()
{pid_t id = fork();if (id < 0) {perror("fork");return 1;}else if (id > 0) { //parentprintf("parent[%d] is sleeping...\n", getpid());sleep(30);}else {printf("child[%d] is begin Z...\n", getpid());sleep(5);exit(EXIT_SUCCESS);}return 0;
}

image-20250807155517337

(4).僵⼫进程危害
  • 进程的退出状态必须被维持下去，因为他要告诉关⼼它的进程（⽗进程），你交给我的任务，我办的怎么样了。可⽗进程如果⼀直不读取，那⼦进程就⼀直处于Z状态.
  • 维护退出状态本⾝就是要⽤数据维护，也属于进程基本信息，所以保存在task_struct(PCB)中，换句话说，Z状态⼀直不退出，PCB⼀直都要维护.
  • 那⼀个⽗进程创建了很多⼦进程，就是不回收，就会造成内存资源的浪费！因为数据结构对象本⾝就要占⽤内存，想想C中定义⼀个结构体变量（对象），是要在内存的某个位置进⾏开辟空间！
  • 如果⽗进程⼀直不管,不回收,不获取⼦进程的提出信息,那么Z会⼀直存在!会内存泄露.

image-20250807161938145

(5).孤⼉进程

  • ⽗进程如果提前退出，那么⼦进程后退出，进⼊Z之后，那该如何处理呢？

  • ⽗进程先退出，⼦进程就称之为“孤⼉进程”

  • 孤⼉进程被1号init进程养，当然要有init进程回收喽。

  • 孤儿进程是父进程退出了,子进程还没有退出,那么子进程就会被1号init进程领养;这个期间,孤儿进程如果是在运行的,就是R状态;如果是阻塞的,就是S状态,等等

#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) {//childprintf("I am child, pid : %d\n", getpid());sleep(10);}else {//parentprintf("I am parent, pid: %d\n", getpid());sleep(3);exit(0);}return 0;
}

image-20250807163157107

image-20250807163448351

3. 进程优先级

  • 优先级 vs 权限
    • 优先级：能得到资源，先后的问题
    • 权限：是否能得到某种资源
(1).基本概念
  • cpu资源分配的先后顺序(就是进程得到cpu资源的先后顺序)，就是指进程的优先权（priority）。
  • 优先权⾼的进程有优先执⾏权利。配置进程优先权对多任务环境的linux很有⽤，可以改善系统性能。
  • 还可以把进程运⾏到指定的CPU上，这样⼀来，把不重要的进程安排到某个CPU，可以⼤ 改善系统整体性能。

image-20250809090052678

(2).查看系统进程

在linux或者unix系统中，⽤ps ‒la命令则会类似输出以下⼏个内容：

image-20250812213629852

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

  • UID : 代表执⾏者的⾝份,替代用户名称(用户名给人看的，系统看数字)
  • PID : 代表这个进程的代号
  • PPID ：代表这个进程是由哪个进程发展衍⽣⽽来的，亦即⽗进程的代号
  • PRI ：代表这个进程可被执⾏的优先级，其值越⼩越早被执⾏;PRI: 进程的优先级，默认:80
  • NI ：代表这个进程的nice值;NI: 进程优先级的修正数据，叫做nice值，默认0

image-20250812214204265

(3).PRI and NI

进程真实的优先级 = 默认PRI(80)+NI

如果原先PRI是90,NI是10.将NI调整为-10之后PRI为70.优先级调整不基于原始优先级,只⽤80+ NI得到新优先级PRI的值.

  • PRI即进程的优先级，或者通俗点说就是程序被CPU执⾏的先后顺序，此值越⼩进程的优先级别越⾼

  • 那NI就是nice值，其表⽰进程可被执⾏的优先级的修正数值

  • PRI值越⼩越快被执⾏，那么加⼊nice值后，将会使得PRI变为：PRI(new)=PRI(old)+nice

  • 这样，当nice值为负值的时候，那么该程序将会优先级值将变⼩，即其优先级会变⾼，则其越快被执⾏

  • 所以，调整进程优先级，在Linux下，就是调整进程nice值

  • nice其取值范围是-20⾄19，⼀共40个级别。

  • Linux进程的优先级范围[60, 99]

    如果优先级设⽴不合理,会导致优先级低的进程⻓时间得不到CPU资源,进⽽导致:进程饥饿.

(4).PRI vs NI
  • 需要强调⼀点的是，进程的nice值不是进程的优先级，他们不是⼀个概念，但是进程nice值会影响到进程的优先级变化。
  • 可以理解nice值是进程优先级的修正修正数据
(5).查看进程优先级的命令

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

  • top
  • 进⼊top后按“r”‒>输⼊进程PID‒>输⼊nice值

image-20250812214701232

注意：

  • 其他调整优先级的命令：nice，renice
  1. nice启动新进程时设置优先级

基本语法

nice -n [niceness值] 命令

示例

#启动my_program,nice 值为 `10`
nice -n 10 ./my_program

注:如果省略 -n，则默认 增加 10（相当于 -n 10）。

  1. renice修改已经运行的进程的优先级

基本语法

renice -n [新nice值] [-p pid] [-g pgrp] [-u user]
  • -p pid：指定进程 ID（默认）。
  • -g pgrp：按进程组 ID 调整。
  • -u user：调整用户的所有进程。

注意:非 root 用户只能把 nice 值调得更大（降低优先级）。

示例

#把PID为12345的进程的nice值调整为-5
renice -n -5 -p 12345
#可简写为
renice -5 12345

# 将用户czj的所有进程 nice值调整为-5
sudo renice -5 -u czj
  • 系统函数：

这些系统调⽤了解即可,⽤的时候再查

image-20250812214824439

(6).补充概念-竞争、独⽴、并⾏、并发
  • 竞争性: 系统进程数⽬众多，⽽CPU资源只有少量，甚⾄1个，所以进程之间是具有竞争属性的。为了⾼效完成任务，更合理竞争相关资源，便具有了优先级
  • 独⽴性: 多进程运⾏，需要独享各种资源，多进程运⾏期间互不⼲扰
  • 并⾏: 多个进程在多个CPU下分别，同时进⾏运⾏，这称之为并⾏
  • 并发: 多个进程在⼀个CPU下采⽤进程切换的⽅式，在⼀段时间之内，让多个进程都得以推进，称之为并发

image-20250812215215062

image-20250812215306218

4. 进程切换

(1).Linux2.6内核进程O(1)调度队列(Linux真实调度算法)

image-20250813121820792

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

image-20250813122126468

image-20250813122543366

切换和调度共同构成了调度器

  • 补充：
    • 分时操作系统–基于时间⽚公平调度,优先级⾼也要等当前时间⽚结束再调度;此外很多⽀持内核优先级抢占;
    • 实时操作系统–⽴刻响应,多⽤在⼯业领域;

操作系统为了能让更多⼈使⽤,既⽀持实时⼜⽀持分时,只不过分时操作系统这个功能⼀般被编译内核裁掉了或者被关掉的.

image-20250813122441961

(2).⼀个CPU拥有⼀个runqueue
  • 如果有多个CPU就要考虑进程个数的负载均衡问题
(3).优先级
  • 普通优先级：100〜139（我们都是普通的优先级，想想nice值的取值范围，可与之对应！）
  • 实时优先级：0〜99（不关⼼）
(4).活动队列

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

  • nr_active: 总共有多少个运⾏状态的进程

  • queue[140]: ⼀个元素就是⼀个进程队列，相同优先级的进程按照FIFO规则进⾏排队调度,所以，数组下标就是优先级！

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

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

  • bitmap[5]:⼀共140个优先级，⼀共140个进程队列，为了提⾼查找⾮空队列的效率，就可以⽤5*32个⽐特位表⽰队列是否为空，这样，便可以⼤ 提⾼查找效率！

image-20250813123433768

(5).过期队列

  • 过期队列和活动队列结构⼀模⼀样

  • 过期队列上放置的进程，都是时间⽚耗尽的进程

  • 当活动队列上的进程都被处理完毕之后，对过期队列的进程进⾏时间⽚重新计算

(6).active指针和expired指针
  • active指针永远指向活动队列
  • expired指针永远指向过期队列
  • 可是活动队列上的进程会越来越少，过期队列上的进程会越来越多，因为进程时间⽚到期时⼀直都存在的。
  • 没关系，在合适的时候，只要能够交换active指针和expired指针的内容，就相当于有具有了⼀批新的活动进程！
(7).总结
  • 在系统当中查找⼀个最合适调度的进程的时间复杂度是⼀个常数，不随着进程增多⽽导致时间成本增加，我们称之为进程调度O(1)算法！

四.环境变量

image-20250818220723961

1. 基本概念

image-20250818220452398

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

2. 常⻅环境变量

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

    要执⾏⼀个程序,必须先找到它! -> bash通过PATH来找;
    系统中存在环境变量,来帮助系统找到⽬标⼆进制⽂件! ->环境变量:PATH,即系统中搜索指令的默认搜索路径!

    image-20250818221147935

  • HOME : 指定⽤⼾的主⼯作⽬录(即⽤⼾登陆到Linux系统中时,默认的⽬录)

  • SHELL : 当前Shell,它的值通常是/bin/bash。

  • USER:当前⽤户是谁;

  • LOGNAME:当前登录的⽤户是谁;
    (注:su后USER和LOGNAME不变; su -后USER和LOGNAME都变成root;)

  • HISTSIZE:记录历史命令的条数(history命令可以拿到最近1000条历史命令);

  • TERM:终端类型(跟字符设备有关,不⽤管);

  • HOSTNAME:当前主机主机名;

  • SSH_CLIENT:当前从哪个客户端登录的 进程号 端⼝号;

  • SSH_TTY:当前是哪⼀个终端设备;

  • LS_COLORS:ls配⾊⽅案;

  • MAIL:邮件环境变量;

  • LANG:编码格式;

  • PWD:当前⼯作路径;

  • OLDPWD:上⼀⼯作路径.

3. 查看环境变量⽅法

echo $NAME //NAME:你的环境变量名称

测试PATH

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

  1. 对⽐./hello执⾏和之间hello执⾏

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

  3. 将我们的程序所在路径加⼊环境变量PATH当中, export PATH=$PATH:hello程序所在路径(export不写的话,关了xshell新加的地址就没了)

  4. 对⽐测试

image-20250818221530469

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

  1. echo: 显⽰某个环境变量值

    image-20250818221702241

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

    image-20250818221716961

    image-20250818221807804

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

    image-20250818221729886

  4. unset: 清除环境变量(包括本地变量)

    image-20250818221828393

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

    image-20250818221900035

  • bash会记录两套变量:1.环境 2.本地

5. 环境变量的组织⽅式

image-20250818221933478

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

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

(1).命令⾏第三个参数
#include <stdio.h>//mian函数的参数最多可以有三个
int main(int argc, char *argv[], char *env[])
{int i = 0;for(; env[i]; i++){printf("%s\n", env[i]);}return 0;
}

image-20250818222203894

(2).getenv

image-20250818222240505

(3).通过第三⽅变量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声明。

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”
  • 再次运⾏程序，发现结果有了！说明：环境变量是可以被⼦进程继承下去的！想想为什么？

五.程序地址空间

1. 研究平台

  • kernel 2.6.32
  • 32位平台

2. 程序地址空间回顾

我们在讲C语⾔的时候，⽼师给⼤家画过这样的空间布局图

image-20250818222717195

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

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

image-20250818222847364

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) { //childprintf("child[%d]: %d : %p\n"， getpid()，g_val, &g_val);}else { //parentprintf("parent[%d]: %d : %p\n"， getpid()， g_val, &g_val);}sleep(1);return 0;
}

输出

image-20250818223159694

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

#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 { //parentsleep(3);printf("parent[%d]: %d : %p\n"， getpid()， g_val, &g_val);}sleep(1);return 0;
}

输出结果：

image-20250818223627218

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

  • 变量内容不⼀样,所以⽗⼦进程输出的变量绝对不是同⼀个变量
  • 但地址值是⼀样的，说明，该地址绝对不是物理地址！
  • 在Linux地址下，这种地址叫做 虚拟地址
  • 我们在⽤C/C++语⾔所看到的地址，全部都是虚拟地址！物理地址，⽤⼾⼀概看不到，由OS统⼀管理

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

4. 进程地址空间

  • 虚拟地址空间，一共会讲4次(这是第一次讲,有些未提及的会在后面讲到)

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

分⻚&虚拟地址空间

image-20250822215729711

image-20250822215809929

说明:

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

image-20250822215929429

5. 虚拟内存管理 - 第⼀讲

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

image-20250822220250784

image-20250822221051297

image-20250822221147360

可以说，mm_struct结构是对整个⽤⼾空间的描述。每⼀个进程都会有⾃⼰独⽴的mm_struct，这样每⼀个进程都会有⾃⼰独⽴的地址空间才能互不⼲扰。先来看看由task_struct到mm_struct，进程的地址空间的分布情况：

image-20250822220352497

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

image-20250822220513908

那既然每⼀个进程都会有⾃⼰独⽴的mm_struct，操作系统肯定是要将这么多进程的mm_struct组织起来的！虚拟空间的组织⽅式(VMA的组织⽅式既vm_area_struct的组织⽅式)有两种：

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

VMA是是概念上的虚拟内存区域，⼀般就对应着⼀个 vm_area_struct

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

既然mm_struct已经记录了各个区的开始和结束位置,为什么除了堆区以外的剩下的连续的区,还需要vm_area_struct呢?
实际情况，在虚拟地址空间中不同的区的内部⾃⼰也不是连续排布的，这个在内部是多个vm_area_striuct映射的空间。可以把它简单的理解为mm_struct是⼤刻度，vm_area_struct是⼩刻度。像尺⼦上⾯的毫⽶和厘⽶似的，只不过不⼀定⻓度是⼀样的。

image-20250822221806839

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

image-20250822221929160

image-20250822221941170

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

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

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

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

image-20250822222040569

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

  • 安全⻛险
    • 每个进程都可以访问任意的内存空间，这也就意味着任意⼀个进程都能够去读写系统相关内存区域，如果是⼀个⽊⻢病毒，那么他就能随意的修改内存空间，让设备直接瘫痪。
  • 地址不确定
    • 众所周知，编译完成后的程序是存放在硬盘上的，当运⾏的时候，需要将程序搬到内存当中去运⾏，如果直接使⽤物理地址的话，我们⽆法确定内存现在使⽤到哪⾥了，也就是说拷⻉的实际内存地址每⼀次运⾏都是不确定的，⽐如：第⼀次执⾏a.out时候，内存当中⼀个进程都没有运⾏，所以搬移到内存地址是0x00000000，但是第⼆次的时候，内存已经有10个进程在运⾏了，那执⾏a.out的时候，内存地址就不⼀定了
  • 效率低下
    • 如果直接使⽤物理内存的话，⼀个进程就是作为⼀个整体（内存块）操作的，如果出现物理内存不够⽤的时候，我们⼀般的办法是将不常⽤的进程拷⻉到磁盘的交换分区中，好腾出内存，但是如果是物理地址的话，就需要将整个进程⼀起拷⾛，这样，在内存和磁盘之间拷⻉时间太⻓，效率较低。

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

  • 地址空间和⻚表是OS创建并维护的！是不是也就意味着，凡是想使⽤地址空间和⻚表进⾏映射，也⼀定要在OS的监管之下来进⾏访问！！也顺便保护了物理内存中的所有的合法数据 ，包括各个进程以及内核的相关有效数据!

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

    • 因为有地址空间的存在，所以我们在C、C++语⾔上new, malloc空间的时候，其实是在地址空间上申请的，物理内存可以甚⾄⼀个字节都不给你。⽽当你真正进⾏对物理地址空间访问的时候，才执⾏内存的相关管理算法，帮你申请内存，构建⻚表映射关系（延迟分配），这是由操作系统⾃动完成，⽤⼾包括进程完全0感知！！

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

http://www.dtcms.com/a/347761.html

相关文章：

  • Python 文件操作全解析：模式、方法与实战案例
  • openharmony之启动恢复子系统详解
  • 控制建模matlab练习14：线性状态反馈控制器-③极点配置
  • 河南萌新联赛2025第（六）场：郑州大学
  • nodejs 集成mongodb实现增删改查
  • 基于深度学习的中草药识别系统：从零到部署的完整实践
  • CA6150主轴箱系统设计cad＋设计说明书
  • Java 学习笔记（基础篇8）
  • MQTT 核心概念与协议演进全景解读（二）
  • BEVDepth
  • 9.Shell脚本修炼手册---数值计算实践
  • python re模块常用方法
  • 取件码-快递取件助手, 短信自动识别ios app Tech Support
  • Access开发打造专业的开关按钮效果
  • rust语言 (1.88) egui (0.32.1) 学习笔记（逐行注释）（七） 鼠标在控件上悬浮时的提示
  • Meta押注Midjourney：一场关于生成式AI的加速赛
  • 【读代码】SQLBot：开源自然语言转SQL智能助手原理与实践
  • GUAVA 实现限流
  • GEO优化服务商赋能全球数字经济发展 技术创新引领行业新格局
  • Java—— 动态代理
  • 基于Python与Tkinter的校园点餐系统设计与实现
  • Spring Data Redis基础
  • [Vid-LLM] docs | 视频理解任务
  • Windows应急响应一般思路（三）
  • 第1.2节：早期AI发展（1950-1980）
  • 老字号：用 “老根” 熬活的 “新味道”
  • redis---string类型详解
  • 大模型四种常见安全问题与攻击案例
  • mysql的mvcc
  • 大语言模型应用开发——利用OpenAI函数与LangChain结合从文本构建知识图谱搭建RAG应用全流程