iOS 知识点 - 一篇文章带你串通「操作系统 & 内存模型 & 文件系统」

本文重点讲解 iOS 操作系统，Linux/Windows 操作系统待到后续新开文章专门讲解。

总览

目标：一篇文章理清 iOS 三个紧密相关但层次不同的事物：

操作系统（iOS / Darwin）：
- 谁在管理 “进程、线程、虚拟内存页、文件描述符、系统调用” ？
文件系统（APFS）：
- 文件到底存在哪儿？谁在管理 “目录、权限、快照、加密”？
内存模型：
- 进程看到的内存是什么结构？虚拟内存、堆/栈、对象布局、ARC/Swift 并发内存语义 是怎么回事儿？

先看一张分层图，后文会自下而上地讲解相关知识：

┌──────────────────────────────────────────────┐
│               1. App 代码层                   │
│──────────────────────────────────────────────│
│ - 自己的类、模块、业务逻辑等代码                  │
└──────────────────────────────────────────────┘
                     ∇ 调用 API
┌──────────────────────────────────────────────┐
│ 2. 系统高层框架 Cocoa(macOS)/Cocoa Touch(iOS等)│
│──────────────────────────────────────────────│
│ - UIKit / SwiftUI (UI 框架)                   |
│ - Foundation（字符串/集合/文件/RunLoop）        |
│ - 其他框架: AVFoundation、CoreDate 等          |
└──────────────────────────────────────────────┘
                     ∇ 依赖
┌──────────────────────────────────────────────┐
│            3. 语言运行时 + 基础库               |
│──────────────────────────────────────────────│
│ - Objc runtime: `libobjc`                    |
│ - Swift runtime: `libswiftCore`              | 
│ - CoreFoundation: CFString/CFArray/...       |
│ - libSystem: libc, libdispatch, libthread ...|
└──────────────────────────────────────────────┘
                     ∇ 基于
┌──────────────────────────────────────────────┐
│  4. 内核 Darwin / XNU (Mach + BSD + IOKit)    │
│──────────────────────────────────────────────│
│ - 进程/线程调度                                │
│ - 虚拟内存（VM: 页、地址空间、缺页中断）           │ 
│ - VFS + 文件系统（APFS）                       │ 
│ - 网络协议栈、驱动、中断、沙盒、安全策略           │
└──────────────────────────────────────────────┘
                     ∇ 运行在
┌──────────────────────────────────────────────┐
│                  5. 硬件层                    │
│──────────────────────────────────────────────│
│ - ARM CPU + Cache +  MMU                     │
│ - 内存条（DRAM）                               │
│ - 存储：NAND 闪存 / SSD 控制器                  │
└──────────────────────────────────────────────┘

接下来从下往上一层层讲清楚：

硬件 & 存储 → 内核 & 文件系统 → 虚拟内存模型 → 运行时内存模型 → 并发和 I/O。

零、硬件和存储：NAND/SSD 是什么？

简单了解下硬件：

NAND 闪存（NAND Flash）：底层介质
- iPhone / iPad 里的 “存储空间” 本质就是最底层的 NAND Flash 芯片，特点：
  - 断电不丢数据；
  - 按 “物理页” 写入（如 4KB 一页），按 “擦除块” 擦出（一块有多页）；
  - 写入擦除有寿命，不能无限写。
SSD（固态硬盘）： 用 多块 NAND + 控制器 + 固件 做出来的 “固态硬盘设备”。
- 控制器用 FTL（Flash Translation Layer） 把 NAND 的 “物理页/擦除块” 抽象成:
  - 逻辑块设备: 一串逻辑块/扇区（0,1,2... 通常每块 4KB）。
  - 控制器负责：
    - 逻辑块号 -> 物理 NAND 页；
    - 坏块管理、ECC校验；
    - 磨损均衡、缓存优化。
- 对于操作系统来说：
  - 看见的是一个可 “按块号随机读写” 的磁盘；
  - APFS(Apple File System) 就是建立在这个逻辑块设备之上的。

一、Darwin/XNU: iOS 的操作系统内核

1. 操作系统 & 内核的角色

操作系统（OS）： 管理硬件资源（CPU、内存、磁盘、网络）的软件平台，向应用程序 (App) 提供统一的编程接口 (API)。

内核（Kernel）： 操作系统的 “核心”，运行在最高权限级别（内核态），负责：

管理 进、线程；
管理内存；
管理 文件系统/设备/网络/安全；
处理 中断、异常、系统调用 等。

2. iOS 的内核：XNU

iOS 的内核叫 XNU ("X is Not Unix")，它是一个混合内核，主要由三部分组成：

Mach（微内核）：
- 负责 线程&任务、调度、虚拟内存（VM）、进程间通信（IPC） 等；
BSD 子系统：
- 提供 POSIX 接口、VFS（虚拟文件系统）、进程/文件描述符/用户与权限 等；
IOKit：
- 一套面向对象的驱动框架（驱动 GPU、网卡、存储控制器、传感器等设备）

3. Darwin: OS 底座

Darwin：包含 XNU 内核 + 一部分用户态基础库/工具，是 iOS/macOS 的共同底座。

iOS 和 Linux 都是 “类 UNIX” 系统，它们都有 进程、线程、虚拟内存、VFS、POSIX，在 虚拟内存和文件系统的分层思想上 高度一致。

差别在于：

内核的实现：Linux 自有一套，Darwin 是 Mach + BSD

用户态生态：Linux 是 GNU ，Darwin 是 libSystem/CoreFoundation 等。

二、虚拟内存模型: 进程看到的 “内存世界”

虚拟内存（VM）：操作系统提供的一层抽象：

让每个进程都认为自己拥有一个 完整、连续 的地址空间（例如 64-bits 就是 0～2⁶⁴-1）；
实际上，这些虚拟地址被内核通过 页表（Page Table） 映射到 物理内存页，或者 mmap(文件映射 等。

好处：

进程隔离：
- 每个进程有自己的虚拟空间，不会互相踩内存。
灵活内存管理：
- 按需分配页面，不常用的页面可以回收，文件页可以 丢弃后重读。

1. 进程的 “虚拟地址空间” 布局

低地址
┌───────────────────────────────┐
│         代码段(text)           │ // 程序机械码（可执行文件指令的一部分，只读）
├───────────────────────────────┤
│       已初始化数据(data)        │ // 有初始值的 全局/静态变量
├───────────────────────────────┤
│       未初始化数据(bss)         │ // 无初始值的 全局/静态变量（默认为 0）
├───────────────────────────────┤
│                               │
│           堆(heap)            │  // malloc/new/ARC 动态分配的对象、缓冲区
│         (向高地址增长)          │
│             ⬇                │ 
├───────────────────────────────┤
│         映射区(mmap)           │  // 动态库, 内存映射文件、共享内存
├───────────────────────────────┤
│             ⬆                │
│          栈(stack)            │  // 局部变量 (值类型、指针)、函数调用帧 (返回地址、保存寄存器)、部分函数参数
│         (向低地址增长)          │
│                               │
└───────────────────────────────┘
高地址

注意：

代码段并不是从 0x00000000 开始的：
- 低地址一般是未映射区域，访问会崩溃（例如：空 block 的调用）
- 实际的起始地址是由内核+链接器+ASLR（地址空间布局随机化）决定的，每次进程启动可能都不一样。

小扩展： 为什么 <NSGlobalBlock: 0x1024e80f8>、<NSThread: 0x60000172ad00> 直接打印变量，有的地址是9位、有的是12位？

其实在 64-bits 操作系统下，本质都是 64 位，只不过打印变量时，高位0被省略了。

如果使用 %p 打印，就可以看到是 0x0000 0001 024e 80f8 和 0x0000 6000 0172 ad00；
再换算成二进制，就是 0x0000 0000 0000 .... 共 64 位。

2. 页（Page）和页缓存（Page Cache）

页（Page）:
- 虚拟内存和物理内存管理的最小单位，一般是 4KB。
页缓存（Page Cache）:
- 内核用来 缓存文件内容 的物理页集合
- 也是 虚拟内存(物理页) 与 文件系统(文件块) 之间的桥梁。

当你读取文件时（read/mmap）:

内核会：
- 根据 “文件+读取偏移” 算出应该访问文件的哪一块数据（也就是将 “从第 N 个字节开始” 换算成 “从第几个文件块的第几个字节开始”）；
- 把这一块数据所在的磁盘块读入某个物理内存页（这页就挂在 Page Cache 中）；
- 映射到进程的虚拟地址空间。
```
(文件 F, 偏移 X)  ←→  页缓存中的某个物理页 P
  ↑
某进程虚拟地址 VA （通过页表映射到 P）
```
简化理解：
- 文件读：磁盘块 → 页缓存 → 进程缓冲区/映射；
- 文件写：进程缓冲区/映射 → 页缓存 → 延迟写回闪存（写时复制）。

3. 栈（Stack）与堆（Heap）

纬度	栈（Stack）	堆（Heap）
管理方式	编译器+内核自动管理静态空间	开发者+ARC共同管理的动态空间
用途	函数调用帧、局部变量、部分参数	动态对象、容器、跨函数/线程长期存在的数据
空间分配	连续、先进后出	大部分不连续，会产生内存碎片
分配/释放效率	高（只需要移动栈指针）系统底层分配，配有专门的寄存器存放栈地址，出/入栈都有相应指令	低（维护链表等）库函数分配，无专门的寄存器
生长方式	向低地址生长	向高地址生长
常见问题	递归过深/大局部数组 -> 栈溢出	内存泄漏、碎片化、过高峰值

小扩展：特殊的指针 `Tagged Pointer`

打印以下语句，可能会得到一个 “看起来不太像地址” 的结果：

NSString *s2 = [NSString stringWithFormat:@"%d", 42];
NSLog(@"s2: %@, class = %s, ptr = %p", s2, object_getClassName(s2), s2);

输出示例：

s2: 42, class = NSTaggedPointerString, ptr = 0xab5eac71f5964d2a

Tagged Pointer：64 位下，一种 “把小对象直接编码进指针本身” 的优化技术。
- 由来：
  - 在 64 位架构上，指针是 64 位，但是大部分小对象本身只有 十几/二十 bits 就能表示；
  - 所以 Apple 在 runtime 里约定：
    - 如果一个 “指针” 的 高几位 满足特定模式，就不再把它当作 真实地址，而是当作 “值+类型” 的打包集合解释。
- 这样一来的好处：
  - 对于小对象，不需要再单独分配一块 堆内存，也不用从内存里读数据；
  - 直接在 CPU 寄存器里用 位运算 就能拿到值，既省空间有快速。

Taged Pointer 可能的样子：(🍎未公开)

/// 大致的示意图，实际上的存储方式未公开，且复杂一些。
bit 63                      0
┌────┬───────┬──────────────────────────────┐
│TAG │ META  │ PAYLOAD (实际内容 + 长度等)  │
└────┴───────┴──────────────────────────────┘
  ^     ^                 ^
  |     |                 └─ 字符数据(例如 "4" "2") 的编码位
  |     └─ 编码方式/长度等元信息
  └─────── 标记“这是 tagged pointer 且是哪一类”（string/number/…）

为什么这个地址看起来非常大？
- 地址 0xab5eac71f5964d2a 的高位 0xA → 二进制 1010 —— 最高位是 1，在 64 位 Apple 平台上通常就表示“这是一个 tagged pointer”。

三、APFS: iOS 的文件系统是如何在闪存上 “写数据” 的？

1. 文件系统的职责

文件系统：是操作系统中负责 长期存储管理 的子系统，提供：

命名空间：文件名、目录、路径（如 /var/mobile/...）；
层次结构：目录树、相对/绝对路径；
元数据：大小、创建时间、修改时间、权限、所有者等；
空间管理：在持久存储（NAND/SSD）上分配和回收数据块。

2. iOS 文件系统的演进：HFS+ → APFS

历史简书：

1. 经典 Mac OS                : MFS → HFS+
2. Mac OS 8~9 & 早期 OS X     : HFS+
3. 早期 iOS / 早期 macOS       : HFS+ / HFSX (Mac OS 扩展)
4. iOS 10.3+ & macOS Sierra+  : APFS (Apple File System)

3. APFS (Apple File System) 核心特性

3.1 容器（Container）和卷（Volume）

物理闪存设备（NAND/SSD）
└─ 逻辑块设备 (Block Device)
    └─ APFS Container (一个或多个)
       ├─ Volume: System   (系统只读卷)
       ├─ Volume: Data     (用户数据卷，App 沙盒在这里)
       ├─ Volume: Preboot  (引导相关)
       └─ Volume: VM / 其他内部卷 ...（虚拟内存/缓存等）

Container：占据一个逻辑块设备或分区；
多个卷共享同一个容器的总空间：
- 不需要固定卷大小；
- 谁用谁占，整体控制额度即可。

3.2 Copy-On-Write（写时复制，COW）

修改前:
 Metadata → Block A

修改后:
 Metadata → Block B (新块)
            Block A 仍在，可能被其他快照引用

当需要修改文件或元数据时：
- 不在 旧物理快 上覆盖；
- 而是在空闲区域写一份新块，然后把指针从旧块改到新块。
好处：
- 利于快照、回滚；
- 对闪存友好：少做 “擦一块再写”，多做 “写新块”。

3.3 快照（Snapshot）

t0: Snapshot S0 记录卷的所有元数据指向（A,B,C）
t1: 正常写入新块 D,E,F（旧块 A,B,C 不变）

快照：某个时刻冻结整个卷的逻辑视图
用途：
- iOS 系统更新：更新前打快照，若更新失败可回滚；
- 备份/恢复（macOS 的时间机器）依赖大量快照。

3.4 克隆（Clone）：块级别的 “写时复制” 复制

APFS 的文件克隆：对同一个文件内容的 数据块 做 “引用计数 + 写时复制” 的轻量级复制。

从 “文件系统” 的角度来看：
- 得到了一个 “看起来” 独立的新文件。
从 “磁盘” 的角度来看：
- clone 文件/目录 时，APFS 不复制数据块，只共享同一组数据块；
- 修改任意一个文件时，才会为 clone 的分配新块并写入（写时复制）。

2.5 加密与文件保护（File Protection）

APFS 内置了强加密，iOS 在此基础上实现了 文件级加密（NSFileProtection）:
```
App 写文件 → 指定 NSFileProtection → APFS 用对应密钥加密数据块 → 写入闪存
```
- 在锁屏/未解锁时，某些文件的密钥不会解封，访问文件就会失败；
- 即使拿走闪存芯片，没密钥也无法轻易恢复内容。

四、App 视角：沙盒、路径与 APFS 的映射

1. 沙盒（Sandbox）

沙盒(Sandbox)： 是 iOS 用来隔离 App 的一种机制：

每个 App 在 “Data 卷” 下有一个自己的根目录；
App 默认只能访问自己的沙盒目录（和一些经过系统授权的 共享目录：相册、iCloud 容器等）。

所有路径都在 Data 卷：

/var/mobile/Containers/Bundle/Application/<APP_UUID>/<App>.app   // Bundle

App 沙盒根（位于 APFS Data 卷内部）
├─ Documents/             // 用户文件，可备份
├─ Library/
│    ├─ Caches/           // 缓存，可被系统删除，不备份
│    ├─ Preferences/      // UserDefaults 存在这里
│    └─ Application Support/     // 一般性数据，默认可备份
└─ tmp/                   // 临时文件，可能被随时清理

在代码上都是使用 API 来管理文件，不关心绝对路径。

Bundle.main.resourceURL             // .app 内资源
FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)

五、运行时的内存模型：对象/ARC/自动释放池/COW

1. 对象的内存布局

这里以 swift class 做例举，objc class 请看 runtime 详解篇：https://juejin.cn/post/7571722835658391586

class Person {
    var age: Int
    var name: String
}

/// `Person` 实例在堆上的简化布局：
┌─────────────────────────────────────┐
│  指向类型信息的指针（类似isa/class指针)  │
├─────────────────────────────────────┤
│  引用计数字段 (Swift RC)            │
├─────────────────────────────────────┤
│  age: Int                      │
├─────────────────────────────────────┤
│  name: String (一个引用/值)     │
└─────────────────────────────────────┘

objc class 类似: isa + 一堆 ivar；
swift class 有自己的 元数据 和 引用计数 实现。

name 本身又是一个结构，可能指向另一个堆缓冲区（COW 字符串底层存储）。

2. ARC (Automatic Reference Counting)

ARC 是 编译器协助的引用计数机制：

编译器在需要的地方插入 retain/release 调用；
开发者通过 strong/weak 等方式控制对象生命周期。
规则：
- 新建：RC = 1;
- 新的强引用：RC += 1;
- 强引用释放/置空：RC -= 1;
- RC 变为 0 时，调用 deinit/dealloc 释放内存。

3. Property 属性修饰符

@property 相关知识点详解篇：https://juejin.cn/post/7571734313923297314

4. Autorelease Pool 自动释放池

autorelease 对象：

这些对象不会立即减少 RC，而是先被放入当前线程的 Autorelease Pool;
当 pool 被销毁时，再批量 release。

主线程上，每一轮 RunLoop 都会自动包装在一个隐式的 Autorelease Pool 中：

RunLoop 一轮:
┌──────────────────────────────────────────────────┐
│ push AutoreleasePool                             │
│ 处理事件/Timer/Block/UI （期间产生 autorelease 对象）│
│ pop AutoreleasePool → release                    │
└──────────────────────────────────────────────────┘

子线程上，无自动生成的 @autoreleasepool，如果有大量临时对象，应手动加一下，避免长时间占用内存。

RunLoop 相关知识点详解篇：https://juejin.cn/post/7576556950332309504

六、并发内存语义：数据竞争、GCD、actor、Sendable

多线程 相关知识点详解篇：https://juejin.cn/post/7581324171398201390

七、文件系统与内存模型的交汇：I/O 全路径可视化

一次文件读取： 从 Swift 到闪存。

let data = try Data(contentOf: url)

执行路径：

[ 调用 Data(contentOf:) ]
           ↓
   [ Foundation/CF ] （封装 POSIX API）
           ↓
     [ POSIX I/O ]   （open/read 或 mmap）
           ↓
       [ VFS 层 ]     （解析路径 -> 找到 APFS 上的 vnode）
           ↓
       [ APFS ]     (找到文件块 ->  Container 中的逻辑块号)
           ↓
     [ 块设备驱动 ] （逻辑块号 -> NAND 控制器）
           ↓
     [ NAND/SSD ]: 读出物理页数据
           ↓
    [ 内核的页缓存 ]  （把数据缓存到物理内存页）
           ↓  
    [ 进程虚拟内存 ]
    - read: 把页缓存中的数据 copy 到用户缓冲区
    - mmap: 进程虚拟地址映射到物理页

最终拿到的 data 本质就是：

进程的 “虚拟地址空间” 中的一块 堆内存；
其内容来自 内核页缓存；
页缓存又对应了 APFS 容器 中的 逻辑块 和 底层 NAND 页。

八、iOS【操作系统、内存模型、文件系统】的知识链路总结

最后再重新看一遍关系图吧：

硬件层:
  - ARM CPU, Cache, MMU
  - NAND/SSD (物理页/擦除块)

内核层 (Darwin / XNU):
  - Mach VM: 虚拟内存、页、地址空间、缺页中断
  - BSD: VFS, POSIX I/O, 进程/线程/FD, 套接字
  - 文件系统: APFS (Container/Volume, COW, snapshot, clone, encryption)

语言/运行时层:
  - ObjC runtime: isa, 消息发送, 引用计数, autoreleasepool
  - Swift runtime: 类型元数据, ARC, COW, actor
  - 并发工具: GCD, NSOperationQueue, Swift Concurrency (Task/actor/Sendable)

框架层:
  - Foundation, UIKit/SwiftUI, AVFoundation, CoreData, ...

应用层:
  - App 代码: 业务逻辑, ViewController, ViewModel, Service
  - 使用: FileManager/Data/URLSession/CoreData/SQLite
  - 设计: 缓存策略, 持久化策略, FileProtection, 多线程/actor 设计

posted @ 2025-12-09 20:13 齐生阅读(1) 评论(0) 收藏举报

刷新页面返回顶部

qisheng-blogs

iOS 知识点 - 一篇文章带你串通「操作系统 & 内存模型 & 文件系统」

总览

零、硬件和存储：NAND/SSD 是什么？

一、Darwin/XNU: iOS 的操作系统内核

1. 操作系统 & 内核的角色

2. iOS 的内核：XNU

3. Darwin: OS 底座

二、虚拟内存模型: 进程看到的 “内存世界”

1. 进程的 “虚拟地址空间” 布局

2. 页（Page）和页缓存（Page Cache）

3. 栈（Stack）与堆（Heap）

小扩展：特殊的指针 `Tagged Pointer`

三、APFS: iOS 的文件系统是如何在闪存上 “写数据” 的？

1. 文件系统的职责

2. iOS 文件系统的演进：HFS+ → APFS

3. APFS (Apple File System) 核心特性

3.1 容器（Container）和卷（Volume）

3.2 Copy-On-Write（写时复制，COW）

3.3 快照（Snapshot）

3.4 克隆（Clone）：块级别的 “写时复制” 复制

2.5 加密与文件保护（File Protection）

四、App 视角：沙盒、路径与 APFS 的映射

1. 沙盒（Sandbox）

五、运行时的内存模型：对象/ARC/自动释放池/COW

1. 对象的内存布局

2. ARC (Automatic Reference Counting)

3. Property 属性修饰符

4. Autorelease Pool 自动释放池

六、并发内存语义：数据竞争、GCD、actor、Sendable

七、文件系统与内存模型的交汇：I/O 全路径可视化

八、iOS【操作系统、内存模型、文件系统】的知识链路总结

公告

qisheng-blogs

iOS 知识点 - 一篇文章带你串通「操作系统 & 内存模型 & 文件系统」

总览

零、硬件和存储：NAND/SSD 是什么？

一、Darwin/XNU: iOS 的操作系统内核

1. 操作系统 & 内核的角色

2. iOS 的内核：XNU

3. Darwin: OS 底座

二、虚拟内存模型: 进程看到的 “内存世界”

1. 进程的 “虚拟地址空间” 布局

2. 页（Page）和页缓存（Page Cache）

3. 栈（Stack）与堆（Heap）

小扩展：特殊的指针 Tagged Pointer

三、APFS: iOS 的文件系统是如何在闪存上 “写数据” 的？

1. 文件系统的职责

2. iOS 文件系统的演进：HFS+ → APFS

3. APFS (Apple File System) 核心特性

3.1 容器（Container）和卷（Volume）

3.2 Copy-On-Write（写时复制，COW）

3.3 快照（Snapshot）

3.4 克隆（Clone）：块级别的 “写时复制” 复制

2.5 加密与文件保护（File Protection）

四、App 视角：沙盒、路径与 APFS 的映射

1. 沙盒（Sandbox）

五、运行时的内存模型：对象/ARC/自动释放池/COW

1. 对象的内存布局

2. ARC (Automatic Reference Counting)

3. Property 属性修饰符

4. Autorelease Pool 自动释放池

六、并发内存语义：数据竞争、GCD、actor、Sendable

七、文件系统与内存模型的交汇：I/O 全路径可视化

八、iOS【操作系统、内存模型、文件系统】的知识链路总结

公告

小扩展：特殊的指针 `Tagged Pointer`