总复习：从所有权证明到可关闭系统

为什么总复习不是把 21 章术语再背一遍

全书从 cargo new 走到 multithreaded web server，看似跨越 syntax、types、libraries 和 systems，但可以收束成五个持续复用的问题：

1. 谁拥有 value，谁可以在何时访问，何时 Drop？
2. 哪些合法/失败状态由 type 与 Result 显式表达？
3. 工作在哪个 thread/task 上推进，queue 与资源上界是什么？
4. abstraction 在 compile time 还是 runtime 选择，unsafe/macro 新增了什么责任？
5. system 怎样停止新增、完成已接收工作并证明所有 resources 已退出？

总复习的目标是把 compiler、tests、runtime evidence 与 source structure 对齐。能背出 Arc<Mutex<T>> 不等于能设计并发；能写 async fn 不等于理解 cancellation；能打开本地网页不等于 server 有 protocol/capacity/shutdown contract。

第一条证明链：ownership、borrowing 与 Drop

从函数签名先读 ownership

fn consume(input: String) -> usize { input.len() }
fn inspect(input: &str) -> usize { input.len() }
fn normalize(input: &mut String) { input.make_ascii_lowercase(); }
fn first<'a>(input: &'a str) -> &'a str { &input[..1] }

consume 转移 owner；inspect 只借读；normalize 在 borrow period 内拥有唯一 mutable access；first 的 lifetime 不延长 source，只声明 output 不可比 input borrow 活得久。先读这些关系，再看 function body，很多 move/borrow error 已经可预测。

non-lexical lifetimes 会在最后一次实际使用后结束 borrow，但不会允许 reference 逃出 owner lifetime，也不会放宽“一个 mutable 或多个 immutable”的冲突规则。

owner graph 比 smart-pointer 名称更重要

Box 是单 owner indirection；Rc 是单线程 atomic-free strong count；Arc 是跨线程 atomic strong count；Weak 不增加 strong count；RefCell/Mutex 不增加 owners，而是控制 interior mutation 的 access timing。把它们组合前先回答两轴：是否多 owner？mutation check 在 compile time、runtime borrow 还是 lock guard？

若 allocation v 的 strong-owner 集合为 S(v)，它的释放条件是：

strong cycle 让所有 nodes 的 strong count 永不归零，因此 memory-safe 但 leak。把 parent/back-reference 改为 Weak 才改变 ownership graph；仅调用 clone 或 Drop 无法自动回收环。

MutexGuard、Ref/RefMut、File、TcpStream 和 JoinHandle 都携带 lifecycle meaning。尤其是 guard：安全性依赖它存在，吞吐依赖它尽早 Drop。把 guard 存进长寿命 struct 或跨 I/O/await 持有，可能不违反 types，却破坏 liveness/capacity。

第二条证明链：data types、abstraction 与 failure surface

Struct、Enum、Module 把合法状态收进边界

pub struct WorkerCount(usize);
 
impl WorkerCount {
    pub fn new(value: usize) -> Result<Self, ConfigError> {
        if value == 0 {
            Err(ConfigError::ZeroWorkers)
        } else {
            Ok(Self(value))
        }
    }
}

newtype 建立 distinct identity；private field 阻止 caller 直接构造 zero；Result 把 invalid input 暴露为 recoverable failure。若字段 public，validator 只是建议，不是 invariant。

Option/Result 是最常见 closed state model；业务 enum 可消除 boolean combinations，例如不用 is_connected + has_job + failed，改成 Idle | Running(JobId) | Failed(Error)。patterns 同时解构 data 与约束 control flow。

Generic、dyn Trait、Enum 与 Macro 的选择轴

选择不是“哪个更快”的单轴：

• closed variants 且需要 exhaustive behavior：enum + match
• implementation open、caller concrete type compile time known：generic + bound
• implementation open、runtime heterogeneous collection/plugin：dyn Trait
• 必须接 variable syntax 或生成 items/impl：macro

function、generic 或 enum 已能表达时，不应用 macro 增加 token parsing、expansion diagnostics 与 compile-time dependency。dynamic dispatch 也不自动要求 heap：&dyn Trait 可以借用，Box<dyn Trait> 才拥有 heap object。

Result、panic 与 question-mark propagation

#[derive(Debug)]
enum LoadError {
    Io(std::io::Error),
    Empty,
}
 
fn load(path: &str) -> Result<String, LoadError> {
    let text = std::fs::read_to_string(path).map_err(LoadError::Io)?;
    if text.is_empty() { Err(LoadError::Empty) } else { Ok(text) }
}

Result 用于 caller 有恢复/传播选择的失败；panic 用于无法维持 invariant、programmer bug 或示例中明确不可恢复的边界。unwrap/expect 把 Result 转成 panic，必须能说明为什么 Err 在该 boundary 不可能或终止是 policy。

测试证据至少覆盖 success set S、expected failure set F 和 invariant-violation rejection set I：

只测 S 会让 malformed input、permission errors、channel disconnect 与 panic paths 在上线后首次执行。

第三条证明链：tests、CLI 与 crate delivery

三层测试对应三种可见性

doc tests 同时验证 examples 可编译、public path 可发现和文档未漂移。cargo test filter -- --ignored 中双横线前由 Cargo 解释，后面由 test binary 解释；默认并行要求 fixtures 不共享文件名、port 或 global mutation。

minigrep 的边界仍是全书模板

Chapter 12 的 Config::build/run/search/thin main 可推广到 server、tool 和 library：

1. boundary parser 把 argv/env/network bytes 转成 validated config/request
2. core function 只接 typed input，返回 Result 或 pure output
3. outer main 把 error 映射到 stderr/log/status，不混入 success data
4. tests 绕过 process/global state，直接验证 core contract

Cargo artifact 是交付事实

cargo check 快速验证 types，cargo test 验证 behavior，cargo doc/test 验证 docs，cargo package 检查真正将发布的文件；workspace 共用 lock/target 不表示 member 自动获得其他 member 的 dependencies。yank 也不是删除，secret 泄露要 rotate credential。

第四条证明链：threads、async 与容量

Safety、liveness、capacity 分开验收

Send/Sync、ownership 与 MutexGuard 主要帮助 safety；lock order、channel close、wake registration 和 join placement 决定 liveness；fixed workers、bounded queues、timeouts 与 backpressure 决定 capacity。任何一项失败都不能由其他项平均掉。

一个稳定 work queue 至少要求长期到达率小于可用处理率。若 N 个 worker 的单 worker 平均处理率是 μ，arrival rate 是 λ，则必要但不充分的条件是：

即使平均满足，burst、长尾 job 和 synchronized slow tasks 仍会积压，因此还要设 queue bound、deadline 与 rejection policy。

Thread、Channel、Shared State 的 completion edges

move closure 把 owner 送进 thread；JoinHandle::join 建立 completion edge；mpsc send 把 message owner 转给 receiver；all Sender Drop + queue empty 让 recv 返回 Err；Arc<Mutex<T>> 共享 owner 与独占 access，但 guard scope 必须局部。

loop {
    let message = receiver.lock().unwrap().recv();
    match message {
        Ok(job) => job(),
        Err(_) => break,
    }
}

先 let 再 match 让 receiver MutexGuard 在 job 前 Drop。写成 while let Ok(job) = receiver.lock().unwrap().recv() 会让 temporary guard 活到 block 结束，pool 退化串行。

Async 的 poll/wake 与 cancellation

async fn 调用只构造 Future；executor poll 得到 Ready/Pending；Pending 前注册 Waker；wake 只把 task 重新标记为可 poll。join 等全部，select/race 取得先完成者并可能 Drop 其他 futures；partial I/O/transaction 必须考虑 cancellation safety。

blocking I/O 或 CPU-heavy work 不能长期占 async executor thread，应交给 bounded blocking/compute pool。反过来，大量 I/O connections 也不适合无限 thread-per-request。模型选择取决于等待形态与容量，不取决于语法偏好。

第五条证明链：patterns、unsafe、macro 与最终系统

Pattern 是控制流证明工具

refutable pattern 只适合有失败分支的位置；irrefutable pattern 用于 let/parameter。match arms 可各自失败，但整体 exhaustive；guard 增加 runtime condition，却不参与 compiler exhaustiveness proof；at binding 同时验证 subpattern 并保留完整 matched value。

Unsafe 只移动 proof，不删除 proof

unsafe 解锁 raw pointer dereference、unsafe call、mutable static access、unsafe trait impl、union field access；borrow/type checks 仍运行。safe abstraction 必须让所有 safe inputs 都满足 safety contract。测试不能证明不存在 UB，因为 compiler 会假设 language invariants 永不被破坏。

Chapter 21 把所有链路接起来

最终 server 的每一段都能回指前章：

• TcpStream owned move：Ch 4
• request enum/match/Result：Ch 6、9、19
• module/library ThreadPool API：Ch 7、10、14
• testable parser/handler split：Ch 11、12
• boxed FnOnce Job：Ch 13、20
• Arc/Mutex/mpsc/JoinHandle：Ch 15、16
• thread pool 与 async alternatives：Ch 17
• graceful Drop protocol：Ch 15、16、21

综合 readiness 不取平均，而取最弱核心 gate：

这解释了为什么“能返回 200”不能抵消 unbounded queue，“类型检查通过”不能抵消 deadlock，“有 Drop impl”不能抵消 sender 仍活着。

三步完成全书综合验收

小结

• ownership contract 先确定 move/borrow/share，owner graph 与 guards 再确定 smart-pointer/lock choice
• struct/enum/module 建 representation invariant，generic/dyn/enum/macro 分别对应不同开放性与 dispatch/generation contract
• Result 暴露 recoverable failure，panic 表示无法合理继续的 invariant failure；tests 要覆盖 success、failure 和 rejection
• unit/integration/doc tests 与 Cargo package 分别验证内部、public、documentation 和 artifact boundary
• concurrency 必须分别证明 safety、liveness 与 capacity；async 还要处理 poll/wake、blocking boundary 与 cancellation
• unsafe 把 memory proof 交给 programmer，不删除 proof；patterns 与 type-state 能把更多状态证明留给 compiler
• final server 的 protocol、queue、error、test、shutdown 任一 gate 失败，整体就未完成

名词解释