操作系统核心知识深度扩展

原创已于 2025-10-10 14:00:39 修改 · 672 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#网络 #服务器 #linux

于 2025-10-10 08:00:00 首次发布

操作系统核心知识深度扩展

一、进程内存管理与地址空间

1. 虚拟内存体系结构

进程虚拟地址空间布局（Linux x86-64）

内存区域	地址范围	增长方向	存储内容	权限	管理方式
栈空间	0x7fffffffffff向下	↓	局部变量、函数参数、返回地址	RW	编译器自动管理
共享库映射区	栈与堆之间	-	动态链接库、文件映射、匿名映射	RWX	mmap系统调用
堆空间	BSS段向上	↑	动态分配内存	RW	malloc/brk/sbrk
BSS段	Data段之后	-	未初始化全局变量	RW	启动时清零
Data段	Text段之后	-	已初始化全局变量	RW	程序加载时初始化
Text段	0x400000	-	程序代码、常量	RX	只读不可写
保留区	0x0-0x400000	-	空指针保护	None	禁止访问

虚拟内存核心优势：

进程隔离 - 独立地址空间，互不干扰，提高系统稳定性
内存保护 - 精细权限控制（只读/可执行/写时复制），防止越权访问
物理抽象 - 连续虚拟地址映射不连续物理内存，简化编程模型
交换支持 - 物理页可换出到磁盘，实现虚拟内存扩展
共享内存 - 多个进程可映射同一物理页，提高内存利用率

2. 页表层次结构

x86-64四级页表转换

地址位段	用途	页表层级	索引大小	管理内存范围
63:48	符号扩展	-	16位	地址空间符号扩展
47:39	L4索引	PML4	9位(512项)	512GB per entry
38:30	L3索引	PDPT	9位(512项)	1GB per entry
29:21	L2索引	PD	9位(512项)	2MB per entry
20:12	L1索引	PT	9位(512项)	4KB per entry
11:0	页内偏移	-	12位	4KB页内偏移

页表项结构

// x86-64页表项格式
struct page_table_entry {
    uint64_t present : 1;        // 1=页在内存中
    uint64_t rw : 1;             // 0=只读, 1=可写
    uint64_t user : 1;           // 0=内核, 1=用户
    uint64_t pwt : 1;            // 写通模式
    uint64_t pcd : 1;            // 缓存禁用
    uint64_t accessed : 1;       // 访问标志
    uint64_t dirty : 1;          // 脏页标志
    uint64_t ps : 1;             // 页大小(0=4KB,1=大页)
    uint64_t global : 1;         // 全局页(TLB不刷新)
    uint64_t avail : 3;          // 可用位
    uint64_t phys_addr : 40;     // 物理页框地址
    uint64_t reserved : 11;      // 保留位
    uint64_t nx : 1;             // 不执行位
};

TLB缓存机制与性能影响

CPU虚拟地址访问流程：
    │
    ├─→ TLB查找(1-3周期)
    │     ├─→ 命中 → 直接获取物理地址 → 访问内存
    │     └─→ 未命中 → 页表遍历(100-300周期)
    │           ├─→ 4级页表内存访问
    │           ├─→ 更新TLB条目
    │           └─→ 访问物理内存
    │
    └─→ 性能关键：TLB命中率直接影响内存访问性能

TLB优化策略：
• 使用大页(2MB/1GB)减少TLB条目数量
• 数据局部性原理优化访问模式
• TLB预取和推测执行

3. 内存分配算法

伙伴系统(Buddy System)

// 伙伴系统内存块管理
#define MAX_ORDER 11  // 最大2^10=1024页(4MB)

struct free_area {
    struct list_head free_list;   // 空闲块链表
    unsigned long nr_free;        // 空闲块数量
};

// 分配算法步骤：
// 1. 根据请求大小找到合适的order
// 2. 在对应order链表中查找空闲块
// 3. 如无合适块，向上级分裂大块
// 4. 分配后剩余部分加入下级链表

Slab分配器优化小对象

Slab三层结构：
┌─────────────────┐
│   Slab缓存      │ ← 管理同类对象
├─────────────────┤
│   Slab描述符    │ ← 管理物理页
├─────────────────┤
│   对象数组      │ ← 实际分配单元
└─────────────────┘

优势：
• 消除内部碎片
• 快速分配/释放
• 缓存热度保持

二、动态链接深度解析

1. ELF文件结构详细分析

ELF文件组成与双视图

组成部分	执行视图	链接视图	关键技术
ELF Header	✅ 必需	✅ 必需	魔数、入口点、程序头/节区头偏移
Program Header	✅ 必需	❌ 可选	PT_LOAD(可加载段)、PT_DYNAMIC(动态段)
Section Header	❌ 可选	✅ 必需	.text/.data/.bss段定义、符号表信息
.text Section	✅ 代码段	✅ 代码节	机器指令、只读属性
.data Section	✅ 数据段	✅ 数据节	已初始化全局变量
.bss Section	✅ BSS段	✅ BSS节	未初始化数据(不占文件空间)

程序头表关键段类型

// 程序头表条目类型
typedef enum {
    PT_LOAD    = 1,      // 可加载段
    PT_DYNAMIC = 2,      // 动态链接信息
    PT_INTERP  = 3,      // 解释器路径
    PT_NOTE    = 4,      // 辅助信息
    PT_PHDR    = 6,      // 程序头表自身
    PT_TLS     = 7,      // 线程局部存储
} p_type_t;

// 段权限标志
#define PF_X 0x1         // 可执行
#define PF_W 0x2         // 可写  
#define PF_R 0x4         // 可读

2. 动态链接详细机制

符号解析状态机与依赖处理

// 符号解析完整状态
typedef enum {
    SYMBOL_UNRESOLVED = 0,    //  未解析，等待处理
    SYMBOL_RESOLVING,         //  解析中，防止循环依赖
    SYMBOL_RESOLVED,          //  已解析，可直接使用
    SYMBOL_NOT_FOUND,         //  未找到，链接错误
    SYMBOL_WEAK_UNRESOLVED,   //  弱符号未解析(可忽略)
} symbol_state_t;

// 全局符号介入(Global Symbol Interposition)
struct symbol_interpose {
    void *original_addr;      // 原始符号地址
    void *override_addr;      // 覆盖符号地址
    const char *symbol_name;  // 符号名称
    int flags;                // 介入标志
};

GOT/PLT延迟绑定详细流程

首次函数调用时序：
┌─────────┐   1. call printf@plt   ┌─────────┐   2. jmp *printf@got   
│ 主程序  │ ──────────────────────→ │ PLT条目 │ ──────────────────────┐
└─────────┘                        └─────────┘                       │
                                                                      ↓
┌─────────┐   6. 执行真正printf    ┌─────────┐   4. 解析符号地址     ┌─────────┐
│ printf  │ ←───────────────────── │   GOT   │ ←───────────────────── │ 动态    │
│ 函数    │                        │ 条目    │                       │ 链接器  │
└─────────┘                        └─────────┘   3. 调用解析函数     └─────────┘
                                                         ↑
                                                         │ 5. 更新GOT
                                                         └─────────────┐
                                                                       │
后续调用直接路径：                                                     │
主程序 → PLT → GOT(直接指向真实地址) → printf函数                       │
                                                                       │
优化：LD_BIND_NOW=1 环境变量可禁用延迟绑定，启动时解析所有符号 ←───────┘

三、文件系统深度解析

1. VFS统一架构

Linux虚拟文件系统层次

层级	核心组件	主要功能	关键技术
用户空间	系统调用接口	open/read/write/close	兼容POSIX标准
VFS抽象层	文件操作表(inode/fill/dentry)	统一文件模型	多态接口设计
文件系统	ext4/xfs/btrfs驱动	磁盘数据组织	日志、分配策略
页缓存	地址空间操作	缓存管理	回写、预读算法
块设备	IO调度器	请求队列管理	CFQ/Deadline/NOOP
驱动层	NVMe/SCSI/SATA	硬件交互	DMA、中断处理

VFS核心数据结构关系

进程任务结构(task_struct)
    ↓
文件描述符表(files_struct)
    ↓
文件对象(file) → 目录项(dentry) → inode → 地址空间(address_space)
    │              │               │               │
    ↓              ↓               ↓               ↓
文件操作   目录项缓存   文件系统    页缓存
(file_ops)   (dcache)   特定操作   管理

2. 现代文件系统特性对比

主流文件系统特性比较

特性	ext4	XFS	Btrfs	ZFS
日志模式	ordered/journal	journal	COW	COW
最大文件	16TB	8EB	16EB	16EB
最大卷	1EB	8EB	16EB	256ZB
写时复制	❌	❌	✅	✅
数据校验	❌	✅	✅	✅
快照	❌	❌	✅	✅
压缩	❌	❌	✅	✅
去重	❌	❌	✅	✅

ext4文件系统磁盘布局

磁盘布局：
┌────────────────┬─────────────┬─────────────┬─────────────┬─────────────┐
│   引导块       │ 超级块      │ 块组描述符表│ 块位图      │ inode位图   │
├────────────────┼─────────────┼─────────────┼─────────────┼─────────────┤
│ inode表        │ 数据块      │   数据块      │ ...         │ 数据块      │
└────────────────┴─────────────┴─────────────┴─────────────┴─────────────┘

关键特性：
• 扩展属性：支持文件元数据扩展
• 预分配：减少文件碎片
• 延迟分配：提高写入性能
• 日志：保证文件系统一致性

四、进程管理与调度

1. 进程状态机详细分析

Linux进程完整状态转换

状态	内核标识	触发条件	目标状态	资源管理
运行	TASK_RUNNING	获得CPU	运行中	占用CPU
可中断睡眠	TASK_INTERRUPTIBLE	等待资源	运行/停止	可被信号唤醒
不可中断睡眠	TASK_UNINTERRUPTIBLE	等待磁盘IO	运行	不可被信号打断
停止	TASK_STOPPED	收到SIGSTOP	运行	调试状态
僵死	TASK_ZOMBIE	进程退出	终止	等待父进程回收
死亡	EXIT_DEAD	父进程回收	-	资源完全释放

进程描述符关键字段

struct task_struct {
    // 进程状态
    volatile long state;
    int exit_state;
    int exit_code;
    
    // 调度信息
    int prio;
    int static_prio;
    int normal_prio;
    unsigned int policy;
    
    // 内存管理
    struct mm_struct *mm;
    
    // 文件系统
    struct files_struct *files;
    
    // 信号处理
    struct signal_struct *signal;
    
    // 进程关系
    struct task_struct *parent;
    struct list_head children;
    struct list_head sibling;
    
    // 其他重要字段
    pid_t pid;
    pid_t tgid;
    struct thread_struct thread;
};

2. CFS调度器深度解析

CFS完全公平调度核心算法

vruntime计算模型

vruntime = (实际运行时间 × NICE_0_LOAD) / 进程权重

权重计算：
static_prio = MAX_RT_PRIO + nice + 20
weight = prio_to_weight[static_prio]

调度策略：
1. 选择红黑树中最左边(最小vruntime)的进程
2. 运行该进程直到其vruntime超过最小vruntime + 调度粒度
3. 更新vruntime并重新插入红黑树
4. 选择新的最小vruntime进程

多核负载均衡策略

// CPU调度域层次结构
struct sched_domain {
    // 调度域级别
    enum sched_domain_level level;
    
    // 负载均衡参数
    unsigned long busy_factor;
    unsigned int imbalance_pct;
    
    // 拓扑关系
    struct sched_group *groups;
    struct sched_domain *parent;
    struct sched_domain *child;
};

// 负载均衡触发条件：
// 1. 周期性均衡(tick_nohz_idle_balance)
// 2. 空闲CPU拉取工作(pull_task)
// 3. 主动迁移(active_load_balance)
// 4. fork新进程(wake_affine)

五、系统调用与中断

1. 系统调用完整机制

x86-64系统调用详细流程

用户空间系统调用：
┌─────────────────┐  1. 参数设置           ┌─────────────────┐
│   用户程序      │ ─────────────────────→ │  libc包装函数   │
│ (调用write())   │                        │   (syscall.S)   │
└─────────────────┘                        └─────────────────┘
         │                                           │
         │ 2. syscall指令触发异常                    │
         ↓                                           ↓
┌─────────────────┐  3. 切换到内核态     ┌─────────────────┐
│ 系统调用入口    │ ←─────────────────── │  硬件异常处理   │
│ (entry_SYSCALL_64) │                    │    机制        │
└─────────────────┘                       └─────────────────┘
         │ 4. 查找系统调用表
         ↓
┌─────────────────┐  5. 调用处理函数     ┌─────────────────┐
│ 系统调用分发    │ ───────────────────→ │  sys_write()    │
│ (do_syscall_64) │                      │  处理函数       │
└─────────────────┘                      └─────────────────┘
         │ 6. 执行具体操作                    │
         ↓                                  ↓
┌─────────────────┐  7. 返回结果       ┌─────────────────┐
│  系统调用返回   │ ←───────────────── │  文件系统操作   │
│ (syscall_return) │                    │   (VFS层)       │
└─────────────────┘                    └─────────────────┘
         │ 8. 返回用户态
         ↓
┌─────────────────┐
│   用户程序      │
│ (继续执行)      │
└─────────────────┘

系统调用性能优化技术

// 1. vsyscall和vDSO机制
//   将部分无副作用系统调用映射到用户空间
//   如：gettimeofday, time, getcpu

// 2. 快速系统调用指令
//   x86: sysenter/sysexit vs syscall/sysret
//   ARM: svc指令

// 3. 系统调用过滤(seccomp)
//   限制进程可用的系统调用，提高安全性

2. 中断处理架构

x86中断描述符表(IDT)详细结构

中断向量	类型	处理程序	用途
0-31	异常	divide_error等	处理器异常
32-47	中断	IRQ0_TIMER等	硬件中断
128(0x80)	系统调用	system_call	传统系统调用
其他	软件中断	自定义处理	软件生成中断

中断处理完整流程

// 中断处理栈帧
struct pt_regs {
    // 寄存器保存区
    unsigned long r15;
    unsigned long r14;
    // ... 其他寄存器
    unsigned long orig_ax;    // 系统调用号或错误码
    unsigned long ip;         // 指令指针
    unsigned long sp;         // 栈指针
};

// 中断处理步骤：
// 1. 保存现场(pt_regs)
// 2. 中断屏蔽(防止嵌套)
// 3. 调用中断处理程序
// 4. 中断结束(EOI)
// 5. 进程调度检查(need_resched)
// 6. 恢复现场并返回

六、安全机制深度解析

1. Linux安全模块架构

LSM(Linux Security Module)框架

安全决策点：
┌─────────────────┐  1. 钩子函数调用    ┌─────────────────┐
│   内核操作      │ ─────────────────→ │   LSM框架       │
│ (文件访问/网络) │                    │  (安全钩子)     │
└─────────────────┘                    └─────────────────┘
                                               │
                                               ↓ 2. 调用模块钩子
┌─────────────────┐  4. 允许/拒绝      ┌─────────────────┐
│   操作执行      │ ←───────────────── │  安全模块       │
│   或终止        │                    │ (SELinux/AppArmor)
└─────────────────┘                    └─────────────────┘

主流安全模块对比

特性	SELinux	AppArmor	Smack
策略类型	类型强制	路径基准	简化标签
学习模式	复杂	有学习模式	简单
配置复杂度	高	中	低
性能开销	中	低	很低
适用场景	高安全环境	通用服务器	嵌入式

2. 现代漏洞缓解技术

完整的内存保护技术栈

// 编译时防护
#define STACK_PROTECTOR    // 栈保护金丝雀
#define FORTIFY_SOURCE     // 缓冲区溢出检查
#define RELRO              // 重定位只读

// 运行时防护
struct runtime_protections {
    int aslr_enabled;          // 地址空间随机化
    int dep_enabled;           // 数据执行保护
    int cfguard_enabled;       // 控制流防护
    int safe_seh_enabled;      // 安全异常处理
    int cet_enabled;           // 控制流强制技术
};

// ASLR随机化熵值
#define ASLR_ENTROPY_LEVELS {
    .stack = 28,      // 栈随机化位数
    .mmap = 28,       // 内存映射随机化  
    .heap = 32,       // 堆随机化
    .executable = 16, // 可执行文件随机化
    .vdso = 10        // VDSO随机化
};

控制流完整性(CFI)实现机制

传统控制流问题：
正常流程: main() → validate_input() → process_data()
攻击流程: main() → 恶意代码 → system("/bin/sh")

CFI防护机制：
1. 前向边控制流校验(间接调用)
   - 函数指针调用前验证目标有效性
   - 使用影子栈(Shadow Stack)记录合法目标

2. 后向边控制流校验(函数返回)
   - 返回地址保护(Stack Canaries)
   - 返回地址加密(XOR随机化)

3. 实现技术：
   • 编译时插桩(Clang CFI)
   • 硬件支持(Intel CET, ARM BTI)
   • 运行时检查(eCFI)

七、性能优化与调试

1. 完整性能分析工具链

Linux性能优化全景图

工具类别	核心工具	主要功能	适用场景
系统监控	top/htop	实时系统状态	快速问题定位
IO分析	iostat/vmstat	磁盘内存统计	IO瓶颈分析
网络分析	netstat/ss	网络连接状态	网络问题排查
进程跟踪	strace/ltrace	系统调用跟踪	程序行为分析
性能剖析	perf/gprof	函数级性能分析	代码优化
内存分析	valgrind	内存错误检测	内存问题调试
动态追踪	eBPF/SystemTap	内核运行时追踪	深度性能分析

perf工具使用层次

# 1. 系统级分析
perf stat -a sleep 10                    # 统计系统事件
perf record -a -g sleep 10               # 全系统采样
perf report                              # 查看报告

# 2. 进程级分析  
perf stat -p <pid> sleep 10              # 进程事件统计
perf record -p <pid> -g sleep 10         # 进程调用图
perf annotate                            # 源码注解

# 3. 函数级分析
perf probe --add='sys_write'             # 动态探针
perf trace ping google.com               # 系统调用跟踪

2. eBPF革命性技术深度解析

eBPF完整架构与工作流程

eBPB系统架构：
┌────────────────────────────────────────────────────────────┐
│               用户空间工具                                  │
│   (bpftool, BCC, bpftrace, 自定义加载器)                   │
├────────────────────────────────────────────────────────────┤
│              BPF系统调用接口                                │
│   (bpf(), 程序加载/映射管理/附着点)                        │
├────────────────────────────────────────────────────────────┤
│              eBPF验证器 (核心安全机制)                      │
│ • 有向无环图(DAG)检查 - 防止无限循环                       │
│ • 内存访问验证 - 确保指针安全                              │
│ • 类型安全检查 - 防止类型混淆                              │
│ • 资源限制 - 指令数/复杂度限制                            │
├────────────────────────────────────────────────────────────┤
│              eBPF即时编译器(JIT)                           │
│ • 字节码到本地机器码编译                                  │
│ • 接近原生性能(额外开销<1%)                               │
│ • 架构支持: x86, ARM, RISC-V等                           │
├────────────────────────────────────────────────────────────┤
│              eBPF映射系统 (数据持久化)                     │
│ • 哈希表(Hash Map) - 键值存储                             │
│ • 数组(Array) - 快速索引访问                              │
│ • 性能事件(Perf Event) - 用户空间数据输出                 │
│ • 环形缓冲区(Ring Buffer) - 高效流数据处理                │
├────────────────────────────────────────────────────────────┤
│             内核附着点 (事件触发)                          │
│ • kprobes/uprobes - 动态内核/用户空间追踪                 │
│ • tracepoints - 静态内核追踪点                            │
│ • XDP (eXpress Data Path) - 网络包处理                    │
│ • cgroup挂钩 - 资源控制事件                               │
└────────────────────────────────────────────────────────────┘

eBPF程序类型与应用场景

// eBPF程序类型枚举
enum bpf_prog_type {
    BPF_PROG_TYPE_SOCKET_FILTER,    // 网络包过滤
    BPF_PROG_TYPE_KPROBE,           // 内核动态追踪
    BPF_PROG_TYPE_TRACEPOINT,       // 内核静态追踪
    BPF_PROG_TYPE_XDP,              // 高速网络处理
    BPF_PROG_TYPE_CGROUP_SKB,       // cgroup网络控制
    BPF_PROG_TYPE_CGROUP_SOCK,      // cgroup套接字控制
    BPF_PROG_TYPE_SCHED_CLS,        // 流量分类
    BPF_PROG_TYPE_SCHED_ACT,        // 流量动作
    BPF_PROG_TYPE_PERF_EVENT,       // 性能事件处理
    // ... 更多类型
};

// 典型应用场景：
// 1. 网络监控 - 包过滤、流量统计
// 2. 安全监控 - 系统调用过滤、文件访问监控  
// 3. 性能分析 - 函数追踪、资源使用统计
// 4. 故障诊断 - 内核状态实时检查

八、容器化与虚拟化技术

1. 容器命名空间完整隔离

Linux命名空间类型与隔离内容

命名空间	内核标志	隔离内容	关键技术
PID	CLONE_NEWPID	进程ID编号	进程树虚拟化
NET	CLONE_NEWNET	网络设备/端口	虚拟网络设备
MNT	CLONE_NEWNS	文件系统挂载点	挂载传播
IPC	CLONE_NEWIPC	System V IPC	消息队列/共享内存
UTS	CLONE_NEWUTS	主机名域名	独立主机标识
USER	CLONE_NEWUSER	用户/组ID	用户映射
Cgroup	CLONE_NEWCGROUP	控制组	资源限制

容器进程视图 vs 主机视图

容器内PID命名空间(隔离视图)：    主机PID命名空间(真实视图)：
┌──────────────────┐           ┌──────────────────────────┐
│ PID 1: /sbin/init│           │ PID 1000: container-init │
│ PID 2: nginx     │           │ PID 1001: nginx          │
│ PID 3: mysql     │           │ PID 1002: mysql          │
│ PID 4: sshd      │           │ PID 1003: sshd           │
└──────────────────┘           └──────────────────────────┘

用户命名空间映射：
容器内UID:     0     1000   1001
主机UID:   100000  101000  101001
           ↓        ↓       ↓
          root    user1   user2

2. cgroups资源控制详解

cgroups v2统一层次结构

cgroups v2文件系统结构：
/sys/fs/cgroup/
├── cgroup.controllers          # 可用控制器列表
├── cgroup.subtree_control      # 子控制组启用控制器
├── cpu.max                     # CPU配额限制
├── memory.max                  # 内存使用上限
├── memory.high                 # 内存回收阈值
├── pids.max                    # 进程数限制
├── system.slice/               # 系统服务控制组
│   ├── sshd.service
│   └── docker.service
├── user.slice/                 # 用户会话控制组  
│   └── user-1000.slice
└── kubepods.slice/             # Kubernetes Pods
    ├── pod1/
    │   ├── container1/
    │   └── container2/
    └── pod2/

cgroup控制器类型与功能

// 主要cgroup控制器
struct cgroup_controllers {
    // CPU控制
    struct cpu_controller {
        int weight;          // CPU权重(100-10000)
        int max;             // CPU时间上限(us)
        int period;          // 统计周期(us)
    } cpu;
    
    // 内存控制  
    struct memory_controller {
        size_t max;          // 内存硬限制
        size_t high;         // 内存回收阈值
        size_t current;      // 当前使用量
    } memory;
    
    // IO控制
    struct io_controller {
        int weight;          // IO权重
        int max_bps;         // 带宽限制
        int max_iops;        // IOPS限制
    } io;
    
    // 进程数控制
    struct pids_controller {
        int max;             // 最大进程数
        int current;         // 当前进程数
    } pids;
};

九、扩展知识点补充

1. 内核同步机制

Linux内核锁机制对比

锁类型	使用场景	特性	性能特点
自旋锁	短临界区、中断上下文	忙等待、不可睡眠	低延迟、高CPU消耗
互斥锁	长临界区、进程上下文	可睡眠、可重入	高延迟、低CPU消耗
读写锁	读多写少场景	共享读、独占写	读并发性能好
RCU	读多写极少	无锁读取、延迟释放	读性能极佳、写复杂
顺序锁	读多写少、数据简单	写优先、读可能重试	读写都较快

2. 内存回收机制

页面回收算法策略

内存压力检测 → 回收策略选择 → 页面选择 → 回收执行
    │              │            │          │
    ↓              ↓            ↓          ↓
工作集大小      直接回收       LRU算法    页面换出
              vs 后台回收     激活队列    或 丢弃

LRU链表管理

// 双链LRU列表
struct lruvec {
    struct list_head lists[NR_LRU_LISTS];
    // 活跃链表
    struct list_head lru_active;    
    // 非活跃链表
    struct list_head lru_inactive;
    // 统计信息
    unsigned long active_size;
    unsigned long inactive_size;
};

// 页面老化算法：
// 1. 新分配页面加入活跃链表头部
// 2. 定期扫描将冷页面移到非活跃链表
// 3. 回收时优先选择非活跃链表尾部页面