⬅ 上一课🏠 目录下一课 ➡
系统编程

第18课：并发线程

🎯 本课目标

掌握Rust线程创建、JoinHandle、move闭包、线程安全与Send/Sync trait。

1. 线程创建

use std::thread;
use std::time::Duration;

fn main() {
    // 创建线程
    let handle = thread::spawn(|| {
        for i in 1..=5 {
            println!("子线程: {}", i);
            thread::sleep(Duration::from_millis(100));
        }
    });

    for i in 1..=3 {
        println!("主线程: {}", i);
        thread::sleep(Duration::from_millis(100));
    }

    // 等待线程完成
    handle.join().unwrap();
}

✅ 编译验证通过

2. move闭包与线程

use std::thread;

fn main() {
    let v = vec![1, 2, 3];

    // move将v的所有权移入线程
    let handle = thread::spawn(move || {
        println!("向量: {:?}", v);
    });

    handle.join().unwrap();
}

✅ 编译验证通过

3. 线程返回值

use std::thread;

fn main() {
    let handles: Vec<_> = (0..5).map(|i| {
        thread::spawn(move || {
            let result = i * i;
            println!("线程{}: {}²={}", i, i, result);
            result
        })
    }).collect();

    let results: Vec<i32> = handles.into_iter()
        .map(|h| h.join().unwrap())
        .collect();
    println!("结果: {:?}", results);
}

✅ 编译验证通过

4. Send与Sync

自动推导：如果所有字段都Send/Sync，则结构体也Send/Sync。

反例：Rc<T>不是Send（引用计数非原子），RefCell<T>不是Sync（运行时借用检查非线程安全）。

5. 线程栈

线程内存模型： 主线程栈 子线程栈 ┌──────────┐ ┌──────────┐ │ main() │ │ closure │ │ v=Vec │ │ v=Vec │ ← move后 │ handle │ │ │ └──────────┘ └──────────┘ ↓ ↓ ┌──────────────────────────┐ │ 共享堆 │ │ (需要同步机制!) │ └──────────────────────────┘ 每个线程独立栈，默认8MB 堆内存可跨线程访问（但需同步）

📝 练习题

练习1：并行计算

将数组分成N份，每份一个线程计算平方和，最后汇总。

练习2：线程池

实现简单的固定大小线程池。

练习3：scoped threads

使用std::thread::scope实现借用数据的多线程处理。

🏆

成就解锁：并发先锋

掌握Rust线程——fearless concurrency的第一步

⬅ 上一课🏠 目录下一课 ➡

🔬 深度理解：Rust与系统编程

系统编程的核心挑战是在不牺牲安全的前提下获得最大性能。Rust如何实现这个目标：

1. 无GC的内存管理

所有权系统在编译期确定每个值的生命周期，不需要运行时垃圾回收。这意味着：无停顿、可预测延迟、更少内存占用。

2. 零成本抽象到硬件

泛型单态化、内联、LLVM优化——高级代码编译为与手写C相当的机器码。

3. 并发无数据竞争

Send/Sync trait在编译期保证：如果是并发访问，要么只读，要么互斥。数据竞争不可能发生。

📊 Rust vs C/C++对比

特性RustCC++
内存安全✅ 编译期❌ 手动⚠️ 部分RAII
线程安全✅ 编译期❌❌
无GC✅✅✅
零成本抽象✅⚠️ 宏✅ 模板
包管理✅ Cargo❌⚠️ vcpkg
学习曲线陡峭中等极陡

🛡️ 安全编码实践

即使Rust保证内存安全和线程安全，仍需注意：

🧪 实战练习补充

以下练习帮助你将本课知识应用到实际场景：

练习A：代码审查

阅读以下代码片段，找出潜在问题并改进：

// 仔细阅读，思考有什么问题
fn process(data: Vec) -> Vec {
    let mut result = Vec::new();
    for i in 0..data.len() {
        result.push(data[i] * 2);
    }
    result
}

改进建议：使用迭代器、预分配容量、考虑溢出。

练习B：性能对比

用criterion基准测试对比以下实现的性能差异：

  • for循环 vs 迭代器
  • String拼接 vs write!宏
  • Vec::push vs Vec::with_capacity

练习C：API设计

为以下场景设计Rust API：一个支持过期时间的缓存系统。考虑所有权、错误处理和泛型。

📌 本课要点总结

通过本课的学习，你应该掌握以下核心要点：

  1. 理解Rust核心概念背后的设计哲学
  2. 能够将所学知识应用到实际编码中
  3. 知道何时选择哪种工具和模式
  4. 具备阅读和审查Rust代码的能力
  5. 能够独立解决编译器报告的问题

如果某个要点还不够清晰，回顾本课的代码示例和内存图，动手编写代码验证你的理解。

🔗 相关资源

Rust系统编程课程 · 第18课 · 2026

📚 扩展阅读

以下资源帮助你深入学习本课主题：

  • The Rust Programming Language — 官方教程，Rust圣经
  • Rust by Example — 通过示例学习Rust
  • Rust Reference — 语言参考手册
  • Rustnomicon — Unsafe Rust黑魔法指南
  • Too Many Lists — 用Rust实现各种链表

🔑 关键术语回顾

本课涉及的核心概念，确保你理解每一个：

术语说明
所有权Rust内存管理的核心机制，每个值有唯一所有者
借用通过引用访问数据，不获取所有权
生命周期引用有效的范围，编译期分析工具
traitRust的接口/抽象机制，类似其他语言的接口
泛型参数化类型，零成本抽象
模式匹配强大的数据解构和分支机制
零成本抽象高层抽象不引入运行时开销
fearless concurrency编译器保证线程安全

💬 学习建议

  1. 动手编码 — 每个代码示例都在本地运行一遍
  2. 修改实验 — 故意改错代码，看编译器报什么错
  3. 完成练习 — 每课的练习题是巩固知识的关键
  4. 阅读源码 — 看标准库和优秀开源项目的实现
  5. 写项目 — 真正掌握需要构建真实项目

🤔 常见问题

Q: Rust学习曲线真的很陡吗？

A: 前期确实需要适应所有权和借用检查器，但一旦理解了，这些概念会让你的代码更可靠。大多数人2-4周就能上手。

Q: Rust适合什么项目？

A: 系统编程、Web服务、CLI工具、嵌入式、WASM、网络服务、数据库等。基本上需要性能和安全的地方都适合。

Q: 遇到编译错误怎么办？

A: Rust编译器的错误信息非常友好！仔细阅读，通常会指出问题所在和修复建议。也可以用cargo clippy获取更多提示。