全专栏地图与索引

# 全专栏地图与索引

这份文档是整个《程序编程原理》专栏的地图与索引——告诉你每一篇在讲什么、彼此之间的关系、以及在不同身份下应该按什么路径来读。

# 🔢 第 1 卷｜数据的本质

核心命题：计算机如何用有限的位表达无限的信息？

# 1.1 卷内脉络

flowchart LR
    A[1.1 数据编码<br/>位 → 字符] --> B[1.2 整型<br/>补码与位运算]
    B --> C[1.3 浮点型<br/>IEEE 754]
    C --> D[1.4 字符串<br/>不可变与编码]
    D --> E[1.5 值与引用<br/>变量的本质]
    E --> F[1.6 泛型<br/>类型参数化]
    F --> G[1.7 集合容器<br/>数据组织]
    G --> H[1.8 序列化<br/>跨边界传输]
    H --> I[1.9 数据解析<br/>逆向重建]

1
2
3
4
5
6
7
8
9

# 1.2 章节速览

#	文档	关键问题
1.1	数据编码设计原理	ASCII / GBK / UTF-8 / Unicode 怎么演进
1.2	整型与位运算原理	补码为什么是"几何美学"的产物
1.3	浮点型数据设计灵魂	为什么 0.1 + 0.2 ≠ 0.3
1.4	字符串设计的灵魂	为什么所有现代语言都让 String 不可变
1.5	值型变量和引用	"值传递"与"引用传递"的本质区别
1.6	泛型设计灵魂思想	类型擦除 vs 单态化——Java/C++/Rust 的不同
1.7	集合与容器设计原理	ArrayList / LinkedList / HashMap 的取舍
1.8	序列化数据的思想	JSON / Protobuf / Thrift / Avro 的对比
1.9	数据解析设计思想	为什么解析器性能能差 100 倍

# 🧬 第 2 卷｜运行时模型

核心命题：从一行 new 到执行结束，程序里到底发生了什么？

# 2.1 卷内脉络

flowchart LR
    A[2.1 类加载] --> B[2.2 对象创建]
    B --> C[2.3 方法访问]
    C --> D[2.4 函数栈帧]
    D --> E[2.5 字节码与VM]
    E --> F[2.6 JIT优化]
    F --> G[2.7 反射元编程]
    G --> H[2.8 异常机制]

1
2
3
4
5
6
7
8

# 2.2 章节速览

#	文档	关键问题
2.1	类的加载核心原理	双亲委派为何而生
2.2	对象创建流程原理	new 一个对象到底发生多少步
2.3	对象和函数访问原理	vtable / itable / 静态分派
2.4	函数调用栈与栈帧设计	栈帧布局与调用约定
2.5	字节码与虚拟机执行原理	JVM / V8 / Python VM 的执行引擎
2.6	JIT 与运行时优化	C2 / Graal 凭什么"超过 C++"
2.7	反射与元编程核心设计	反射 / Emit / Proxy 的共同本质
2.8	异常机制设计原理	异常从硬件中断到语言层

# ⚡ 第 3 卷｜并发之道

核心命题：从一个线程到多个线程，软件世界发生了什么质变？

# 3.1 卷内脉络

flowchart TB
    subgraph 起源["🌱 起源篇（3.1-3.5）"]
        A1[3.1 线程由来] --> A2[3.2 上下文切换]
        A2 --> A3[3.3 通信] --> A4[3.4 异常] --> A5[3.5 经典案例]
    end
    
    subgraph 矛盾["🔥 矛盾篇（3.6-3.10）"]
        B1[3.6 并发Bug] --> B2[3.7 设计三命题]
        B2 --> B3[3.8 安全策略] --> B4[3.9 锁设计] --> B5[3.10 CAS]
    end
    
    subgraph 范式["🚀 范式篇（3.11-3.14）"]
        C1[3.11 异步同步] --> C2[3.12 单线程模型]
        C2 --> C3[3.13 协程] --> C4[3.14 Actor/CSP]
    end
    
    subgraph 池化["🏊 池化与升华（3.15-3.18）"]
        D1[3.15 池化思想] --> D2[3.16 池核心原理]
        D2 --> D3[3.17 调优技巧] --> D4[3.18 结构化并发]
    end
    
    起源 --> 矛盾 --> 范式 --> 池化
    
    style 矛盾 fill:#ffe6cc
    style 范式 fill:#cfe2ff

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 3.2 章节速览

起源篇

#	文档	关键问题
3.1	线程前世今生探索	进程不够用？1:1/N:1/M:N 演进
3.2	并发上下文切换原理	进程/线程/协程切换代价差异
3.3	线程通信设计思想	共享内存 vs 消息传递
3.4	线程异常设计原理	一个线程死了别的怎么办
3.5	多线程并发经典案例	售票问题揭示的竞态

矛盾篇

#	文档	关键问题
3.6	并发 Bug 源头由来	可见性/原子性/有序性
3.7	并发编程设计思想	分工/同步/互斥三大命题
3.8	并发编程安全设计	不可变/TLS/读写分离/无锁
3.9	锁核心设计和思想	LOCK# 到锁升级的完整链路
3.10	理解 CAS 设计由来	从哲学到硬件，CAS 与 ABA

范式篇

#	文档	关键问题
3.11	异步和同步的设计	同步→多线程→回调→async/await
3.12	单线程模型的思想	单线程为何反而高并发
3.13	协程核心设计思想	挂起/恢复 + 有栈 vs 无栈
3.14	Actor 与 CSP 并发模型	Erlang Actor vs Go channel

池化与升华篇

#	文档	关键问题
3.15	线程池的设计思想	池化思想：生产者-消费者
3.16	线程池设计核心原理	ctl 变量、状态机、Worker 模型
3.17	线程池使用技巧	7 大参数调优实战
3.18	结构化并发设计思想	Kotlin/Swift/Java 21/Trio

# 💾 第 4 卷｜内存的真相

核心命题：每一个 OOM、Full GC、内存泄漏的背后，都是什么物理事实？

# 4.1 卷内脉络

flowchart LR
    A[4.1 虚拟内存<br/>地址空间] --> B[4.2 内存模型<br/>读写一致性]
    B --> C[4.3 堆栈<br/>分配机制] --> D[4.4 缓存对齐<br/>性能约束]
    D --> E[4.5 GC<br/>谁来回收] --> F[4.6 引用<br/>持有语义]
    F --> G[4.7 泄漏诊断<br/>看见隐形] --> H[4.8 数据拷贝<br/>动还是不动]

1
2
3
4
5

# 4.2 章节速览

#	文档	关键问题
4.1	虚拟内存与地址空间	MMU/页表/TLB/COW
4.2	内存模型技术设计	冯·诺依曼到 JMM 演进
4.3	堆和栈内存的设计	栈帧、malloc、glibc bin
4.4	内存对齐与缓存局部性	Cache Line/Padding/伪共享
4.5	内存回收机制设计	标记清除→分代→ZGC
4.6	多种引用技术设计	强/软/弱/虚引用
4.7	内存泄漏与诊断原理	GC Roots/支配树/Heap Dump
4.8	数据拷贝设计原理	浅/深/写时拷贝

# 🖼 第 5 卷｜交互与系统

核心命题：从硬件触点到屏幕像素——用户交互背后是怎样的事件驱动架构？

# 5.1 卷内脉络

flowchart LR
    A[5.1 窗口] --> B[5.2 视图渲染]
    B --> C[5.3 GPU 管线] --> D[5.4 手势事件]
    D --> E[5.5 消息机制] --> F[5.6 跨进程]
    F --> G[5.7 加密]

1
2
3
4
5

# 5.2 章节速览

#	文档	关键问题
5.1	窗口核心设计思想	矩形+事件+坐标系
5.2	视图加载渲染设计	measure/layout/draw
5.3	图形渲染管线原理	GPU 流水线/VSync/合成器/Skia
5.4	手势事件设计灵魂	触点流→状态机→手势
5.5	消息机制设计思想	Handler/Looper/MessageQueue
5.6	跨进程通信设计	管道/共享内存/Binder
5.7	数据加密和解密	对称/非对称/哈希

# 🎁 你能学到什么

🧠 认知层
  1. 看见矛盾的能力
  2. 跨语言抽象的能力
  3. 看见演进的能力

🛠 工程层
  4. 定位疑难杂症的能力
  5. 架构设计的能力
  6. 写出"不出事"代码的能力

🎤 表达层
  7. 面试的能力
  8. 晋升答辩的能力
  9. 指导新人的能力

🚀 长期层
  10. 抗时间淘汰的能力

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 🔄 配套学习方法

# 三遍精读法

📕 第一遍：通读，建立框架（不要深入抠细节）
   → 重点关注每篇的"§00 真实事故" + "§08 一句话总结"
   → 目标：知道每一篇大概在讲什么

📗 第二遍：精读，理解每个"为什么"
   → 重点关注 §02-§05 的核心机制
   → 跟着做笔记/思维导图
   → 目标：能复述给同事听

📘 第三遍：实战，对照项目代码
   → 找自己项目里的对应代码段
   → 用本章节的视角重新审视
   → 目标：能改进或重构现有代码

1
2
3
4
5
6
7
8
9
10
11
12
13

# 笔记模板（每篇都建议这么记）

## X.X [章节标题]

### 核心矛盾
（这一篇解决什么）

### 演进时间线
（1970 → 现在的关键节点）

### 三种以上语言对比
- Java: ...
- Go: ...
- Rust: ...

### 我的项目里的对应代码
（找一段实际代码贴在这里）

### 一句话总结
（用自己的话写）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

再次强调：这不是"速成班"。它要花你 3-6 个月时间，但读完之后，你看待技术的眼光会发生永久性改变。这是它最大的价值。

上次更新: 2026/06/07, 10:26:12

← 专栏的导读和绪论 README→