Huangjin007_头像
【Linux 系统篇(四十)】线程(一):从进程到线程,再到虚拟内存与分页机制封面图

【Linux 系统篇(四十)】线程(一):从进程到线程,再到虚拟内存与分页机制

在这里插入图片描述

  大家好,欢迎来到 huangjin007_ 的博客
  ⭐ 个人主页:huangjin007_
  🔥 文章收录专栏:Linux 内功修炼手册(系统篇)
总会有一些坚持
能从冰封的土地里
培育出十万朵怒放的蔷薇

Linux 系统篇(四十) —— 从进程到线程,再到虚拟内存与分页机制

文章目录


写在前面:
这篇文章整理了好久,内容可能会有一点点长哦~
不过相信看完之后,一定会有所收获的!
那么,我们开始吧! ฅ՞Ⱉ՞ฅ ྀི


前言

  在正式学习 Linux 线程之前,我们需要先思考一个问题:

  为什么已经有了进程,还需要线程?

  在之前的学习中,我们已经接触过进程,知道进程是操作系统进行资源分配的基本实体,操作系统通过 task_struct 等内核数据结构管理进程。

  我们也知道,一个进程拥有自己的代码、数据、堆、栈以及虚拟地址空间。

  那么问题来了:

  假设现在有一个程序,它需要同时完成三件事情:

  1. 接收用户输入;
  2. 处理用户提交的数据;
  3. 将处理结果写入文件。

  如果只有一个执行流,那么程序就需要按照一定的顺序执行这些任务。当其中某项任务需要等待时,其他任务也可能无法及时得到执行。

  有没有办法让一个程序内部拥有多个执行流,让它们分别完成不同的任务,同时又能够共享程序的大部分资源呢?

  这时候线程就出现了。

  不过,要真正理解 Linux 线程,仅仅知道线程是进程内部的一个执行流还远远不够。

  我们还需要回答:

  • Linux 是如何在内核中管理线程的?
  • 为什么多个线程能够共享同一个进程的资源?
  • 线程之间共享的资源究竟是什么?
  • 为什么 Linux 线程可以做到比传统进程更加轻量?
  • 虚拟地址空间和物理内存之间又有什么关系?

  这些问题最终都会指向一个核心知识点:虚拟地址空间与分页机制。


一、Linux 线程:从进程到执行流

1.1 什么是线程?

  先回顾一下我们之前学习的进程。

  在操作系统中,可以将一个进程理解为:

  进程 = 内核数据结构 + 程序代码和数据 + 执行所需的上下文

  其中,内核通过 task_struct 等数据结构描述和管理进程。

  而线程的定义是:

  线程是进程内部的一条执行路线,更准确地说,是一个进程内部的控制序列。

  这句话看起来简单,但其中有两个非常重要的概念:

  • 进程:承担资源管理的角色。
  • 线程:承担具体执行任务的角色。

  举个例子。

  假设我们有一个家庭,家庭拥有一套房子、一些家具和其他生活资源。家庭成员可以共同使用这些资源,但每个人都有自己的事情要做。

  有人负责工作,有人负责学习,有人负责做饭。

  这里:

  • 家庭可以理解为进程;
  • 家庭拥有的资源可以理解为进程资源;
  • 家庭成员可以理解为线程;
  • 每个家庭成员正在做的事情,可以理解为线程的执行流。

  一个家庭可以有一个成员,也可以有多个成员。

  同样,一个进程至少拥有一个执行线程,也可以拥有多个执行线程。

  这就解释了为什么以前我们学习的普通进程并没有与线程的概念冲突:

  以前接触的单线程进程,只是一个进程内部只有一条执行流的特殊情况。

1.2 进程和线程有什么区别?

  理解了基本概念,我们再从操作系统的角度看两者的区别。

  操作系统教材中有两个非常经典的定义:

  • 进程是系统资源分配的基本实体。
  • 线程是 CPU 调度的基本单位。

  注意,这里说的是两个不同的角度。

对比维度进程线程
主要职责资源管理与隔离执行具体任务
资源关系拥有独立的进程资源共享所属进程的大部分资源
调度关系不直接等同于单个执行流CPU 调度的基本单位
地址空间通常拥有独立地址空间同一进程内共享地址空间
独立性进程之间相互隔离线程之间共享较多资源

  这里需要注意一个细节:

  进程和线程并不是完全对立的两个概念。

  进程更强调资源的组织与管理,线程更强调执行。

  可以简单理解为:

  进程负责提供资源,线程负责使用资源。

  当然,这是一种帮助理解的抽象。

1.3 Linux 中的线程是什么?

  接下来进入 Linux 的实现层面。

  在 Linux 中,我们经常会听到一个词:

  LWP(Light Weight Process),轻量级进程。

  Linux 使用统一的任务管理机制来实现进程和线程。对于内核来说,线程并不是完全独立于进程之外的新实体,而是和进程一样由 task_struct 表示、可以被单独调度的任务;一个 LWP 通常就对应一个这样的可独立调度任务。

  例如,一个进程在已有主线程的基础上又创建了三个线程:

一个进程(线程组,tgid 相同)

运行

选择/切换

选择/切换

选择/切换

选择/切换

共享

共享

共享

共享

CPU 处理器

内核调度器

主线程
task_struct
group_leader

线程 T1
task_struct

线程 T2
task_struct

线程 T3
task_struct

进程级共享资源
虚拟地址空间 / 文件描述符表
信号处理方式等

  图中的主线程和 T1/T2/T3 各自对应一个 task_struct,共四个 task_struct;每个 task_struct 描述一个可被内核独立调度的执行流,也都可以看作一个 LWP。

  它们各自拥有自己的:

  • 线程 ID;
  • CPU 寄存器上下文;
  • 栈;
  • 调度状态;
  • 内核栈。

  同时,同一线程组(tgid 相同)内的这些任务共享虚拟地址空间、文件描述符表、信号处理方式等进程级资源。主线程的 task_struct 作为 group_leader,其 pid 等于进程的 tgid;其他线程的 tgid(线程所在进程的编号) 与主线程相同。

  每个线程可以独立调度,但不必拥有一整套独立的进程资源。

  这里还有一个容易混淆的地方:

  Linux 并不是简单地把传统进程缩小一下就变成线程了。

  Linux 内核使用 task_struct 统一描述可调度任务,再通过不同的资源共享关系,区分通常意义上的进程和线程。

  例如:

  • fork() 创建子进程,通常会得到独立的地址空间。
  • pthread_create() 创建线程,会让新线程与创建者共享地址空间。

  因此,更准确的说法是:

  Linux 使用统一的任务描述结构和调度机制,通过共享资源的方式实现线程。

1.4 为什么 Linux 不另外设计一套 TCB?

  现在我们产生一个新的问题:

  既然线程和进程有所区别,为什么 Linux 不直接设计一个专门的线程控制块 TCB(Thread Control Block)?

  从设计角度看,完全可以这么做。

  例如:

进程 PCB
负责管理进程资源

线程 TCB 1
描述执行流

线程 TCB 2
描述执行流

线程 TCB 3
描述执行流

  进程负责管理资源,线程控制块负责描述每一个线程。

  但是这样做也会带来一个问题:

  线程和进程在创建、销毁、调度、等待等方面存在大量相似的管理需求。

  如果再单独设计一套线程描述结构和管理机制,就可能产生大量重复代码。

  Linux 选择了另一种方案:

  复用 task_struct,让进程和线程使用统一的任务管理机制。

  这样做有几个好处:

  1. 不需要另外建立一套完全独立的线程调度体系。
  2. 可以复用已有的任务管理代码。
  3. 进程和线程能够使用统一的调度机制。

1.5 Linux 线程共享资源的本质

  现在已经知道:

  每个线程都有自己的 task_struct。

  那么问题来了:

  既然每个线程都有自己的 task_struct,它们又是如何共享资源的?

  这里就需要引入一个非常重要的内核数据结构:

  mm_struct。

  在 Linux 中,mm_struct 用来描述一个进程的用户虚拟地址空间。

  我们可以先看一张图:

线程 T1

线程 T2

task_struct
T1 的任务描述符

task_struct
T2 的任务描述符

mm_struct
共享地址空间描述

页表

物理内存

  可以看到:

  两个线程拥有不同的 task_struct,但是它们指向同一个 mm_struct。

  这意味着什么?

  意味着它们共享同一个用户虚拟地址空间,也就是能够访问同一份代码、全局数据、堆以及共享映射区域。

  例如:

int global_value = 100;

  如果一个进程创建了两个线程,那么两个线程都可以通过同一个全局变量的虚拟地址访问这份数据。

  一个线程修改了 global_value,另一个线程也能够观察到修改后的结果(当然,实际并发访问还需要考虑同步问题)。

  这就是线程共享资源的本质之一。

  不过,千万不要认为线程什么都共享。

  线程依然拥有自己的:

  • 用户栈;
  • 内核栈;
  • CPU 寄存器上下文;
  • 程序计数器;
  • 线程局部存储(TLS)。

  另外,Linux 线程在信号处理、文件描述符等方面也有各自的规则和共享关系。

  所以我们可以先记住:

  线程之间共享进程的大部分资源,但每个线程也必须保留自己独立执行所需要的上下文。

1.6 函数和线程执行流之间有什么关系?

  这里再补充一个容易产生误解的知识点。

  有些资料会说:

  线程就是执行某一个函数。

  这种说法不够严谨。

  例如:

void Task()
{
    FunctionA();
    FunctionB();
}

  线程可以从 Task() 的入口地址开始执行,然后在执行过程中继续调用其他函数。

  所以,更准确地说:

  线程拥有自己的执行起点和执行上下文,CPU 根据线程保存的程序计数器等信息,决定下一条要执行的指令。

  而函数经过编译后,其指令会被安排在程序的代码区域中,每条指令都有对应的虚拟地址。

  因此,多个线程可以:

  • 从不同函数入口开始执行;
  • 调用相同的公共函数;
  • 访问相同的全局变量;
  • 操作相同的堆内存。

  线程之间不是简单地把代码区切成互不相交的几块,而是共享代码,同时拥有各自独立的执行状态。

  到这里,我们已经理解了 Linux 线程的基本思想:

  多个独立的执行流,共享同一份进程资源。

  但还有一个关键问题没有解释:

  这些线程为什么能够看到同一份资源?

  答案要从虚拟地址空间说起。


二、为什么需要虚拟地址空间和分页机制?

2.1 一个问题:物理内存应该如何分配?

  假设现在计算机只有物理内存,没有虚拟内存和分页机制。

  当操作系统加载一个程序时,需要为它分配一段物理内存。

  如果程序希望直接使用连续的内存地址,那么操作系统就必须找到一段足够大的连续物理内存。

  例如:

物理内存

程序 A

程序 B

程序 C

空闲

  现在假设程序 B 退出了。

  那么它占用的物理内存就会被释放:

物理内存

程序 A

空闲

程序 C

空闲

  随着程序不断创建和退出,物理内存中就可能出现很多大小不同的空闲区域。

  这时候又来了一个新程序,它需要一块较大的连续内存。

  虽然整个物理内存中可能存在足够多的空闲空间,但是这些空间分散在不同的位置,无法直接拼成一块连续区域。

  这就是外部内存碎片问题。

  问题的根源在于:程序需要连续的地址空间,而物理内存不一定能够提供足够大的连续区域。

  那么,有没有一种办法:

  让程序看到的内存地址是连续的,但是实际使用的物理内存可以分散在不同的位置?

  有。

  这就是虚拟内存与分页机制要解决的问题。

2.2 虚拟地址空间与物理内存的解耦

  我们可以换一种思路。

  既然程序需要的是连续的地址空间,那么操作系统就提供一套逻辑上的地址空间给程序使用。

  这套地址空间就是:

  虚拟地址空间(Virtual Address Space)。

  程序运行时使用虚拟地址,而不是直接拿着物理地址访问内存。

  操作系统和硬件通过页表建立虚拟地址与物理地址之间的映射关系。

  例如:

物理内存

页表映射

虚拟地址空间

虚拟页 0

虚拟页 1

虚拟页 2

虚拟页 3

0 → 1

1 → 3

2 → 5

3 → 8

物理页框 1

物理页框 3

物理页框 5

物理页框 8

  注意:

  虚拟地址空间看起来是连续的,但是映射到物理内存后,可以分散在不同位置。

  这样一来,程序就不再需要一整块连续的物理内存了。

  这就是虚拟内存与分页机制带来的重要好处。

2.3 什么是页和页框?

  既然需要建立虚拟地址和物理地址之间的映射关系,那么就需要规定一个统一的划分单位。

  这个单位就是页。

  这里需要区分两个概念:

  页(Page):虚拟地址空间中的固定大小的数据块。

  页框(Page Frame):物理内存中固定大小的存储区域。

  例如,在一个采用 4KB 基本页大小的系统中:

物理内存

虚拟地址空间

Page 0
4KB

Page 1
4KB

Page 2
4KB

Frame 0
4KB

Frame 1
4KB

Frame 2
4KB

  一个虚拟页可以映射到任意一个符合条件的物理页框。

  例如:

虚拟页 0  ------> 物理页框 5
虚拟页 1  ------> 物理页框 2
虚拟页 2  ------> 物理页框 8

  这样就建立了虚拟内存和物理内存之间的对应关系。

  这里还有一个细节:

  页和页框的大小相同,但它们不是同一个概念。

  • 页强调虚拟地址空间中的划分。
  • 页框强调物理内存中的划分。

2.4 为什么虚拟地址可以连续,物理地址却不连续?

  现在我们把前面的内容联系起来。

  假设一个程序有三个虚拟页:

虚拟地址空间

Page 0

Page 1

Page 2

  操作系统可以将它们映射到:

物理内存

Frame 0

Frame 1

Frame 2

Frame 3

Frame 4

Frame 5

Frame 6

Frame 7

  假设实际映射关系为:

映射到

映射到

映射到

Page 0

Frame 6

Page 1

Frame 1

Page 2

Frame 4

  虽然物理内存中使用的页框并不连续,但程序仍然可以按照连续的虚拟地址访问自己的数据。

  原因就在于:

  CPU 使用虚拟地址访问内存,硬件通过页表找到对应的物理地址。

  所以,程序并不需要知道自己的数据究竟放在物理内存的什么位置。

2.5 每个进程为什么可以拥有相同的虚拟地址?

  现在再思考一个问题。

  假设系统同时运行两个程序:

  程序 A 和程序 B。

  它们都使用虚拟地址 0x400000。

  这会不会发生冲突?

  不会。

  因为不同进程通常拥有各自独立的用户虚拟地址空间和页表。

进程 A

虚拟地址 0x400000

页表 A

物理地址 0x100000

进程 B

虚拟地址 0x400000

页表 B

物理地址 0x800000

  虽然两个进程使用了相同的虚拟地址,但是通过不同的页表,最终映射到了不同的物理位置。

  所以:

  虚拟地址相同,不代表物理地址相同。

  当然,如果操作系统有意让多个进程共享某些物理页面,也可以让不同进程的页表映射到同一个物理页框。


三、操作系统如何管理物理内存?

  前面已经知道,物理内存被划分成了一个个固定大小的页框。

  但现在还有一个问题:

  物理内存中有这么多页框,操作系统如何知道哪些页框正在使用,哪些页框空闲?

  答案是:

  先描述,再组织。

3.1 struct page:描述物理页

  在 Linux 内核中,使用 struct page 结构体来描述物理内存中的页。

  可以把它理解为:

  每一个物理页,都有一个对应的管理信息。

/* include/linux/mm_types.h */
struct page {
    /* 原⼦标志,有些情况下会异步更新 */
    unsigned long flags;
    union {
        struct {
            /* 换出⻚列表,例如由zone->lru_lock保护的active_list */
            struct list_head lru;
            /* 如果最低为为0,则指向inode
             * address_space,或为NULL
             * 如果⻚映射为匿名内存,最低为置位
             * ⽽且该指针指向anon_vma对象
             */
            struct address_space* mapping;
            /* 在映射内的偏移量 */
            pgoff_t index;
            /*
             * 由映射私有,不透明数据
             * 如果设置了PagePrivate,通常⽤于buffer_heads
             * 如果设置了PageSwapCache,则⽤于swp_entry_t
             * 如果设置了PG_buddy,则⽤于表⽰伙伴系统中的阶
             */
            unsigned long private;
        };
        struct { /* slab, slob and slub */
            union {
                struct list_head slab_list; /* uses lru */
                struct { /* Partial pages */
                    struct page* next;
#ifdef CONFIG_64BIT
                    int pages; /* Nr of pages left */
                    int pobjects; /* Approximate count */
#else
                    short int pages;
                    short int pobjects;
#endif
                };
            };
            struct kmem_cache* slab_cache; /* not slob */
            /* Double-word boundary */
            void* freelist; /* first free object */
            union {
                void* s_mem; /* slab: first object */
                unsigned long counters; /* SLUB */
                struct { /* SLUB */
                    unsigned inuse : 16; /* ⽤于SLUB分配器:对象的数⽬ */
                    unsigned objects : 15;
                    unsigned frozen : 1;
                };
            };
        };
    };
    union {
        /* 内存管理⼦系统中映射的⻚表项计数,⽤于表⽰⻚是否已经映射,还⽤于限制逆向映射搜索 */
        atomic_t _mapcount;
        unsigned int page_type;
        unsigned int active; /* SLAB */
        int units; /* SLOB */
    };
    ...
#if defined(WANT_PAGE_VIRTUAL)
    /* 内核虚拟地址(如果没有映射则为NULL,即⾼端内存) */
    void* virtual;
#endif /* WANT_PAGE_VIRTUAL */
    ...
}

  为什么结构体中会使用大量的 union?

  因为一个物理页在不同场景下可能承担不同的角色。

  例如:

  • 普通内存页;
  • 页缓存中的页面;
  • SLAB 分配器管理的页面;
  • 交换缓存中的页面。

  如果为每种用途都单独保存一套字段,就会浪费大量内存。

  因此,内核使用联合体让不同用途共享部分存储空间。

3.2 struct page 中几个重要成员

1. flags:页面状态标志

unsigned long flags;

  这个字段用于保存物理页的各种状态。

  例如:

  • 页面是否被锁定;
  • 页面是否被修改;
  • 页面是否处于活跃状态;
  • 页面是否属于某种特殊管理状态。

  这些状态通常通过不同的比特位表示。

  例如:

PG_locked:表示页面处于锁定状态。
PG_dirty:表示页面是脏页,也就是内容被修改过,需要考虑写回等处理。
PG_uptodate:表示页面的数据已经准备好,可以正常使用。

  为什么使用一个整数的不同位来保存状态?

  因为一个整数可以同时保存多个独立的布尔状态。

  例如:

flags:

0000 0000 0000 0001

  某一位为 1,可以表示对应状态成立。

  这样就不需要为每一个状态单独定义一个变量。

2. _mapcount:映射计数

atomic_t _mapcount;

  这个字段与物理页被映射的情况有关。

  简单理解:

  它用于记录物理页被多少个用户页表映射,以及辅助内核判断页面的映射状态。

3. virtual:内核虚拟地址

  在某些内核配置和历史实现中,还可以看到与 virtual 相关的字段。

  它用于表示物理页对应的内核虚拟地址。

3.3 struct page 为什么不直接保存物理地址?

  既然 struct page 用来描述物理页,那么为什么不直接在结构体中保存它对应的物理地址呢?

  实际上,内核可以通过物理页框号 PFN(Page Frame Number)来确定物理页的位置。

  假设:

  • 基本页大小为 4KB;
  • 某个物理页框号为 100。

那么这个页框的起始物理地址就是:

100 × 4096 = 409600 100 \times 4096 = 409600 100×4096=409600

  也就是:

物理页框起始地址 = P F N × P A G E _ S I Z E 物理页框起始地址 = PFN \times PAGE\_SIZE 物理页框起始地址=PFN×PAGE_SIZE

  因此,在能够确定 PFN 和页大小的情况下,就可以计算出页框的物理地址。

  没有必要在每个描述结构中都重复保存同一份地址信息。

3.4 struct page 需要消耗多少内存?

  既然每一个物理页都需要管理信息,那么这些管理信息本身会不会占用大量内存?

  我们来做一个计算。

  假设:

  • 物理内存为 4GB;
  • 基本页大小为 4KB;
  • 暂时假设一个 struct page 占用 40 字节。

  首先计算物理页的数量:

4 G B 4 K B = 2 32 2 12 = 2 20 \frac{4GB}{4KB}=\frac{2^{32}}{2^{12}}=2^{20} 4KB4GB​=212232​=220

  也就是:

1 , 048 , 576 1,048,576 1,048,576

  约为 104 万个物理页。

  每个页面需要一个 40 字节的描述结构,那么:

1 , 048 , 576 × 40 = 41 , 943 , 040 B 1,048,576 \times 40=41,943,040B 1,048,576×40=41,943,040B

  换算之后大约是 40MB。

  也就是说,假设使用 40 字节的页面描述结构,那么管理 4GB 物理内存所需的描述信息大约占 40MB。

  这个计算主要是帮助我们理解页面管理的空间开销。

3.5 为什么页面大小不能无限增大或无限减小?

  页面大小并不是越大越好,也不是越小越好。

  如果页面太大:

  假设一个程序只需要使用 1KB 的内存,但操作系统以 4MB 为单位分配页面,那么就可能出现较大的页内空间浪费。

  这叫作内部碎片。

  如果页面太小:

  同样大小的内存就需要划分成更多页面。

  这会增加:

  • 页面管理信息;
  • 页表项数量;
  • 地址转换管理开销。

  所以,页面大小需要在内存利用率和管理开销之间取得平衡。

3.6 物理页是如何被组织起来的?

  前面介绍了 struct page,它负责描述物理页。

  但是仅仅有描述结构还不够。

  操作系统还需要把这些页面组织起来,方便查找、分配和回收。

  这里又回到了经典思想:

  先描述,再组织。

  可以把它想象成:

物理页 0  -> struct page
物理页 1  -> struct page
物理页 2  -> struct page
物理页 3  -> struct page
...

  Linux 会根据具体内存模型管理这些页面。

  例如,物理内存管理涉及:

  • 内存节点;
  • 内存区域;
  • 伙伴系统;
  • 页面链表;
  • 页面缓存等。

  操作系统不仅需要描述页面,还需要通过合适的数据结构快速找到页面。


四、页表:虚拟地址如何找到物理地址?

  现在我们已经解决了两个问题:

  1. 虚拟地址空间可以让程序看到连续的地址。
  2. 物理内存通过页框进行划分,并由操作系统进行管理。

  接下来,就到了整个分页机制最核心的部分:

  虚拟地址究竟是如何转换成物理地址的?

  答案就是页表。

4.1 页表是什么?

  页表(Page Table)是用于建立虚拟页与物理页框之间映射关系的数据结构。

  例如:

在这里插入图片描述

  通过页表,CPU 就能够根据虚拟地址找到对应的物理页框。

  这里要特别注意:

  页表项并不是简单地保存一个物理地址。

  它通常还包含一些控制信息。

  例如:

  • 页面是否存在;
  • 是否允许读写;
  • 是否允许执行;
  • 是否允许用户态访问;
  • 其他与硬件架构有关的控制位。

  例如:

页表项内容含义
物理页框地址页面对应的物理位置
Present页面是否存在于内存映射中
R/W读写权限
U/S用户态或内核态访问权限
NX是否禁止执行(支持该特性的架构)

  这些权限信息可以帮助操作系统和处理器实现内存保护。

4.2 为什么 32 位系统需要这么多页表项?

  我们以 32 位处理器为例。

  32 位地址一共能够表示:

2 32 = 4 G B 2^{32}=4GB 232=4GB

  假设每个页面大小为 4KB:

4 K B = 2 12 4KB=2^{12} 4KB=212

  那么整个 4GB 虚拟地址空间就需要划分为:

2 32 2 12 = 2 20 = 1 , 048 , 576 \frac{2^{32}}{2^{12}}=2^{20}=1,048,576 212232​=220=1,048,576

  也就是说:

  一个完整覆盖 4GB 虚拟地址空间的页表,需要能够表示 1,048,576 个虚拟页。

  如果每一个页表项占用 4 字节,那么:

1 , 048 , 576 × 4 = 4 , 194 , 304 B = 4 M B 1,048,576 \times 4=4,194,304B=4MB 1,048,576×4=4,194,304B=4MB
  也就是说,一张完整的单级页表需要 4MB。

  注意,这里说的是一个能够覆盖整个 4GB 虚拟地址空间的完整单级页表。

  它还存在另一个问题:

  如果我们要求这张页表本身连续存储,那么它又需要一整块 4MB 的连续物理内存。

  这与最初引入分页机制、希望减少对连续物理内存依赖的目标有些矛盾。

  有没有更好的办法?

  有。

  把一张大页表拆成多个小页表,再用另一张表管理这些小页表。

  这就是多级页表。

4.3 从单级页表到两级页表

  假设我们把原来的 1,048,576 个页表项拆分成 1024 份。

  每份包含 1024 个页表项。

  那么:

1024 × 1024 = 1 , 048 , 576 1024 \times 1024=1,048,576 1024×1024=1,048,576

  依然能够覆盖整个 4GB 虚拟地址空间。

  每一张小页表的大小是:

1024 × 4 B = 4096 B = 4 K B 1024 \times 4B=4096B=4KB 1024×4B=4096B=4KB

  这样就形成了:

  • 1024 张页表;
  • 每张页表 4KB。

  不过,现在又产生了一个问题:

  这 1024 张页表应该由谁来管理?

  于是,我们再引入一张表:

  页目录表(Page Directory)。

  页目录表中的每一个表项,都可以指向一张二级页表。

  结构如下:

页目录表

页表 1023

页表项 0

页表项 1

页表项 2

...

页表项 1023

页表 ...

页表项 0

页表项 1

页表项 2

...

页表项 1023

页表 2

页表项 0

页表项 1

页表项 2

...

页表项 1023

页表 1

页表项 0

页表项 1

页表项 2

...

页表项 1023

页表 0

页表项 0

页表项 1

页表项 2

...

页表项 1023

表项 0

表项 1

表项 2

...

表项 1023

  这样一来:

  页目录表负责管理页表,页表负责管理物理页框映射。

4.4 为什么多级页表能够节省内存?

  有人可能会问:

  之前一张完整页表需要 4MB。

  现在拆成 1024 张页表,每张 4KB。

  那么:

1024 × 4 K B = 4 M B 1024 \times 4KB=4MB 1024×4KB=4MB

  总大小不是一点都没有变化吗?

  确实,如果 1024 张页表全部分配,那么页表部分的总大小依然是 4MB。

  但关键在于:

  多级页表可以按需分配。

  一个程序不一定会使用整个 4GB 虚拟地址空间。

  例如,一个程序只使用了 10MB 的虚拟地址空间。

  每张页表能够覆盖:

1024 × 4 K B = 4 M B 1024 \times 4KB=4MB 1024×4KB=4MB

  那么,10MB 的连续虚拟地址空间大约需要:

10 M B 4 M B = 2.5 \frac{10MB}{4MB}=2.5 4MB10MB​=2.5

  向上取整后,需要 3 张页表。

  所以,只需要分配:

  • 一张页目录表;
  • 三张二级页表。

  没有使用到的地址区域,对应的页表就可以不分配。

  这就是多级页表最重要的优点:

  它能够根据实际使用情况分配页表,避免为大量未使用的虚拟地址预先分配映射表。

  另外,每张页表本身只有 4KB,可以作为一个普通物理页进行管理,不需要再寻找一整块 4MB 的连续物理内存。

  简单理解: 每个页表项都可以管理一个虚拟页,一个虚拟页大小是4KB,然后小页表里面有1024个页表项,一共可以管理1024 x 4KB,即4MB,那一个大页表里面有1048576个页表项,那它们管理虚拟页就是1048576 x 4KB,即4GB,然后我们需要10MB,要是用大页表就会造成浪费,要是使用小页表就只需要3个就可以了。


五、32 位系统中的两级页表与地址转换

  理解了页目录和页表之后,我们继续深入。

  为什么 32 位虚拟地址能够拆分成三部分?

5.1 32 位虚拟地址的组成

  假设:

  • 虚拟地址为 32 位;
  • 基本页大小为 4KB;
  • 采用经典的两级页表结构。

  由于:

4 K B = 4096 = 2 12 4KB=4096=2^{12} 4KB=4096=212

  所以,一个页面内部有 4096 个字节。

  要表示页面内部的任意一个字节,需要 12 位。

  因此:

  虚拟地址的低 12 位用于表示页内偏移。

  剩下的高 20 位用于查找页表。

  而我们之前又知道:

  每张页表有 1024 个表项。

1024 = 2 10 1024=2^{10} 1024=210

  所以,查找一张表中的 1024 个表项,需要 10 位。

  于是,高 20 位可以继续拆分成两个部分:

  • 一级页号:10 位;
  • 二级页号:10 位。

  最终得到:

在这里插入图片描述

5.2 为什么低 12 位是页内偏移?

  这个问题其实非常简单。

  因为:

2 12 = 4096 2^{12}=4096 212=4096

  一个 4KB 页面包含 4096 个字节。

  页面内部的字节编号为:

0 ∼ 4095 0 \sim 4095 0∼4095

  对应的二进制范围就是:

000000000000
        到
111111111111

  恰好需要 12 位。

  因此:

  • 高 20 位决定访问哪个虚拟页;
  • 低 12 位决定访问这个虚拟页中的哪个字节。

  例如:

虚拟地址:

0000000000 0000000001 111111111111
| 一级页号 | 二级页号 |   页内偏移 |

  可以得到:

  • 一级页号:0;
  • 二级页号:1;
  • 页内偏移:4095。

在这里插入图片描述

  理解这个划分之后,后面所有的地址转换都可以围绕这三个部分展开。

5.3 CR3:页目录表的入口在哪里?

  现在我们已经知道,虚拟地址被拆成了三个部分。

  但是,CPU 应该从哪里开始查找页目录表?

  在经典的 32 位 x86 两级分页模型中,需要用到一个特殊寄存器:

  CR3 寄存器。

  CR3 保存当前地址转换所使用的页目录基址相关信息。

  简单理解:

  CPU 可以通过 CR3 找到当前使用的页目录表。

  结构如下:

CR3

页目录表

一级页号索引

页表

二级页号索引

物理页框

页内偏移

物理地址

  所以,当一个进程需要使用自己的地址空间时,硬件就需要使用与该地址空间对应的页表体系。

  在经典的地址空间切换过程中,会涉及 CR3 的切换。

5.4 两级页表究竟如何完成地址转换?

  我们通过一个具体例子来理解。

  假设虚拟地址被拆分为:

一级页号:0
二级页号:1022
页内偏移:4095

  现在开始查找。

  第一步:通过 CR3 找到页目录表。

  CR3 中保存着当前页目录基址。

  第二步:使用一级页号查找页目录。

  一级页号为 0。

  所以访问页目录表中的第 0 项。

  通过该表项,找到对应的二级页表基址。

  第三步:使用二级页号查找页表。

  二级页号为 1022。

  所以访问刚才找到的页表中的第 1022 项。

  该表项给出目标物理页框的基址。

  假设这个物理页框基址为:

0x22222000

  第四步:结合页内偏移。

  页内偏移为 4095,也就是:

0xFFF

  因此:

物理地址 = 物理页框基址 + 页内偏移 物理地址=物理页框基址+页内偏移 物理地址=物理页框基址+页内偏移

= 0 x 22222000 + 0 x F F F =0x22222000+0xFFF =0x22222000+0xFFF

= 0 x 22222 F F F =0x22222FFF =0x22222FFF

  最终就找到了我们需要访问的物理地址。

在这里插入图片描述

  整个过程可以总结为:

虚拟地址

提取一级页号

查询页目录表

得到二级页表地址

提取二级页号

查询二级页表

得到物理页框基址

加上页内偏移

得到最终物理地址

  这里要记住一个核心公式:

物理地址 = 物理页框基址 + 页内偏移 物理地址=物理页框基址+页内偏移 物理地址=物理页框基址+页内偏移


六、MMU 和 TLB:地址转换如何提高效率?

  前面我们已经知道,CPU 使用虚拟地址访问内存,需要通过页表找到物理地址。

  但是,这个过程存在一个问题:

  查找页表本身也需要访问内存。

  在两级页表结构中,完成一次地址转换至少涉及:

  1. 访问页目录表;
  2. 访问二级页表;
  3. 根据物理地址访问目标数据。

  如果页表级数继续增加,地址转换就会变得更加复杂。

  那么,有没有办法减少这些重复的查询过程?

  答案是:

  MMU 和 TLB。

6.1 MMU 是什么?

  MMU 的英文全称是:

  Memory Management Unit,内存管理单元。

  它是处理器中的硬件内存管理单元。

  主要负责虚拟地址到物理地址的转换,同时还负责内存访问权限等相关检查。

  可以简单理解为:

  CPU 产生虚拟地址,MMU 根据当前页表信息完成地址转换。

在这里插入图片描述

  因此,程序通常不需要自己手动查页表。

  地址转换是由硬件自动完成的。

6.2 多级页表为什么会影响效率?

  我们先回顾一下:

  两级页表需要先查页目录,再查二级页表,最后访问真正的数据。

  如果每次访问内存都需要重新完成这套查询,那么开销就会比较大。

  特别是程序经常访问相同页面时,会产生很多重复工作。

  有没有办法把之前查到的映射关系保存起来?

  例如:

虚拟页号 0x100
       |
       v
物理页框 0x500

  如果下一次又访问虚拟页号 0x100,是不是就没有必要再次从头查询页表了?

  这就引出了 TLB。

6.3 TLB:页表映射关系的高速缓存

  TLB 的英文全称是:

  Translation Lookaside Buffer,转译后备缓冲器。

  通常简称为快表。

  它本质上是一种用于缓存地址转换结果的硬件缓存。

  例如:

TLB:物理页框号

TLB:虚拟页号

0x100

0x200

0x300

0x500

0x300

0x800

  假设 CPU 需要访问虚拟地址 0x100123。

  MMU 会先检查 TLB 中是否存在对应的地址转换信息。

  如果存在:

  就可以直接得到物理页框信息,再结合页内偏移形成物理地址。

  如果不存在:

  就需要继续通过页表完成地址转换。

  这就产生了两种情况。

情况一:TLB 命中

CPU

MMU

查询 TLB

找到对应映射

得到物理地址

访问物理内存

  不需要重新遍历多级页表。

情况二:TLB 未命中

CPU

MMU

查询 TLB

没有找到
(TLB Miss)

查询页表

得到物理地址

更新 TLB

访问物理内存

  这样,后续再次访问相同虚拟页时,就有机会直接从 TLB 中获得地址转换结果。


七、缺页异常:为什么访问内存还可能失败?

  现在我们已经知道:

  CPU 通过虚拟地址访问内存,MMU 首先尝试通过 TLB 获取地址转换信息,如果没有命中,再通过页表进行查询。

  但是,又有一个问题:

  如果页表中也没有有效的物理页映射,应该怎么办?

  这时候就需要引入:

  缺页异常(Page Fault)。

7.1 什么是缺页异常?

  缺页异常是处理器在访问虚拟地址时,发现当前地址转换或访问条件无法满足,从而产生的一种异常。

  注意:

  缺页异常不一定意味着程序出错。

  很多时候,它是操作系统正常管理虚拟内存的一种机制。

  例如:

  程序申请了一块虚拟内存,但这块内存对应的物理页面还没有真正分配。

  当程序第一次访问这块内存时,处理器发现页表中没有有效的物理页映射,就会触发缺页异常。

  内核接管后,可以根据具体情况分配物理页框、读取文件内容或者建立映射。

  处理完成后,程序通常可以继续执行。

7.2 缺页异常的处理过程

  我们通过一个简单流程理解:

在这里插入图片描述

  这里有一个非常重要的细节:

  缺页异常处理成功后,通常会重新执行触发异常的那条指令,而不是直接跳过它执行下一条指令。

  因为之前那条指令并没有成功完成访问。

  只有把对应的内存映射处理好,才能让它重新执行并正常完成。

7.3 三种常见的缺页情况

  为了更好地理解,我们把缺页分为三种常见情况。

1. Major Page Fault:主要缺页

  这种情况通常需要进行实际的存储设备 I/O。

  例如:

  程序访问某个文件映射区域,对应的数据当前不在物理内存中。

  内核需要从文件等后备存储中读取数据,然后建立映射。

  这种缺页通常开销较大,因为涉及存储设备访问。

2. Minor Page Fault:次要缺页

  这种情况不需要从磁盘读取页面数据。

  例如:

  物理内存中已经存在对应页面,只是当前进程还没有建立相应的页表映射。

  内核只需要完成相应的映射处理,就可以继续执行。

  写时拷贝(COW)以及部分匿名内存首次访问等场景,也可能产生不需要磁盘读取的缺页异常。

3. 非法内存访问

  例如:

  程序访问了没有合法映射的地址,或者尝试以不允许的方式访问某个页面。

  这种情况下,内核无法通过正常的缺页处理满足访问要求。

  Linux 通常会向进程发送 SIGSEGV 等信号。

  如果程序没有正确处理,通常就会终止。

7.4 缺页异常和段错误有什么区别?

  这两个概念尤其容易混淆。

对比缺页异常段错误(SIGSEGV)
本质处理器产生的异常Linux 发送给进程的信号
原因地址转换或访问条件需要内核处理访问地址非法或权限不允许
处理结果可能成功建立映射并继续执行通常导致程序终止
是否一定是错误不一定通常意味着发生了非法访问

  举个例子。

  程序申请了一块虚拟内存,但对应的物理页还没有分配。

  第一次访问时触发缺页异常。

  内核发现地址合法,于是分配物理页框,建立映射。

  程序继续运行。

  这就是一次正常的缺页处理。

  而如果程序访问一个不属于自己合法映射范围的地址,内核就可能判定为非法访问,并向进程发送 SIGSEGV。

  缺页异常是一种处理器异常,段错误通常是内核对非法内存访问进行处理后发送的信号。

7.5 new 和 malloc 申请内存时到底发生了什么?

  学到这里,我们可以回头思考以前接触过的:

int *p = new int[1000];

  或者:

int *p = malloc(1000 * sizeof(int));

  我们经常会说:

  申请内存就是向操作系统申请物理内存。

  但实际上,这种说法过于简单。

  更准确地说:

  用户程序申请内存,首先涉及用户空间分配器对虚拟地址空间的管理;当需要实际使用页面时,内核才可能进一步分配物理页框并建立映射。

  例如:

int *p = new int[1000];

  这并不意味着执行完这一行代码,操作系统就一定已经为这 1000 个整数全部分配好了独立的物理内存页面。

  具体情况取决于分配器、已有内存、内存映射以及后续访问行为。

  在 Linux 中,用户空间分配器可能通过 brk()、mmap() 等机制获取或管理虚拟地址空间。

  当程序真正访问某些尚未建立物理映射的页面时,可能触发缺页异常,再由内核按需分配物理页框。

  申请虚拟内存,不等于立即分配同等大小的物理内存。


八、回到线程:为什么线程切换通常更加轻量?

  前面花了大量篇幅讲解虚拟地址空间、页表、MMU 和 TLB。

  现在终于可以把这些知识重新联系到线程上了。

  还记得前面讲过的结构吗?

  同一个进程中的多个线程:

  • 各自拥有独立的 task_struct;
  • 共享同一个 mm_struct;
  • 使用同一套用户地址空间和页表。

  这意味着什么?

  意味着线程切换时,通常不需要像切换到另一个地址空间的进程那样切换页表。

8.1 进程切换为什么需要考虑页表?

  假设现在有两个进程:

进程 A

task_struct A

mm_struct A

页表 A

进程 B

task_struct B

mm_struct B

页表 B

  它们拥有不同的用户虚拟地址空间。

  假设 CPU 正在执行进程 A,之后调度器决定执行进程 B。

  那么,CPU 就需要使用进程 B 对应的地址空间。

  在经典的 x86 分页机制中,这就涉及页表切换,也就是与 CR3 等相关的地址空间切换操作。

  因为两个进程的虚拟地址映射关系可能完全不同。

  如果不切换地址空间,就可能使用错误的页表访问内存。

8.2 同一个进程中的线程切换为什么不需要切换地址空间?

  再看两个线程:

线程 T1

线程 T2

task_struct

task_struct

mm_struct

页表

  两个线程共享同一个 mm_struct。

  所以,当 CPU 从 T1 切换到 T2 时:

  虽然需要切换线程的寄存器上下文、栈指针、调度状态等信息,但通常不需要切换到另一套用户地址空间。

  也就是说:

  同一进程内的线程切换通常不需要进行进程地址空间切换,也就通常不需要因为地址空间不同而切换 CR3。

  这就是线程切换通常更加轻量的一个重要原因。

  但这里要强调:

  线程切换并不是没有开销。

  线程切换通常比不同地址空间之间的进程切换更轻量,但并不是任何情况下线程切换都一定更快。

8.3 线程共享资源与独占资源总结

  最后,我们把线程内部的资源关系整理一下。

资源同一进程内的线程
代码区共享
全局数据共享
堆空间共享
动态库映射共享
共享内存映射共享
用户栈各自独立
内核栈各自独立
CPU 寄存器上下文各自独立
程序计数器各自独立
线程局部存储 TLS各自独立

  这张表非常重要。


九、mm_struct、vm_area_struct 和页表之间的关系

  在正式结束之前,我们再把三个重要的内核概念联系起来。

  它们分别是:

  • mm_struct
  • vm_area_struct
  • 页表(Page Table)

  这三个结构在 Linux 虚拟内存管理中承担不同的职责。

9.1 mm_struct:整个地址空间的管理者

  mm_struct 用来描述一个进程的用户虚拟地址空间。

  可以把它理解成整个地址空间的总账。

  其中包含地址空间管理所需要的各种信息,例如:

  • 地址空间相关统计信息;
  • 虚拟内存区域管理信息;
  • 页表相关信息;
  • 内存映射相关状态。

  因此,mm_struct 并不是某一块具体的内存,而是描述和管理整个用户虚拟地址空间的数据结构。

9.2 vm_area_struct:描述一段虚拟内存区域

  一个进程的虚拟地址空间并不是所有位置都可以随意访问。

  不同区域有不同的用途和访问权限。

  例如:

  • 代码段;
  • 数据段;
  • 堆;
  • 栈;
  • 动态库映射区域;
  • mmap 映射区域。

  Linux 使用 vm_area_struct 描述一段连续的虚拟地址区域。

  例如:

进程虚拟地址空间

mm_struct

vm_area_struct
代码区域

vm_area_struct
数据区域

vm_area_struct
堆区域

vm_area_struct
栈区域

  每个 VMA 都会描述相应区域的起始地址、结束地址、访问权限以及映射相关信息等。

9.3 页表:负责真正的地址映射

  那么页表又负责什么?

  页表主要负责:

  将虚拟地址映射到物理页框。

  所以三个结构可以这样理解:

数据结构作用类比
mm_struct管理整个虚拟地址空间总账
vm_area_struct描述一段虚拟地址区域分区明细
页表建立虚拟页到物理页框的映射地址地图

  三者之间相互配合,完成 Linux 的虚拟内存管理。


十、知识串联:从线程到物理内存

  到这里,本篇的所有核心知识已经讲完。

  我们再把整套知识体系从头到尾串联一次。

在这里插入图片描述

  现在再回到最初的问题:

  Linux 为什么能够实现轻量级线程?

  因为 Linux 使用统一的 task_struct 描述和管理可调度任务。

  同一个进程中的多个线程拥有各自独立的执行上下文,但能够共享同一个 mm_struct 和用户地址空间。

  而虚拟地址空间又通过页表映射到实际的物理内存。

  因此,多个线程可以在同一套地址空间中访问相同的代码、数据和堆资源,同时又保留各自独立的执行状态。

  这就是 Linux 线程实现的基本思想。


结语:

  今天的内容到这里就结束了,希望你能有所收获~

干货整理到手抖,觉得有用的话,赏个三连回回血?__(:ᗤ」ㄥ)_ _

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/Huang_jin007/article/details/170804534

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--