Rust Book Summary 项目解析：无畏并发编程指南

本文基于 Rust Book Summary 项目中的第16章内容，深入讲解 Rust 语言中并发编程的核心概念和实践方法。Rust 以其"无畏并发"的特性著称，通过所有权系统和类型系统在编译期就能防止数据竞争等问题。

并发编程的挑战

在深入 Rust 并发特性前，我们需要理解并发编程面临的典型问题：

1. 竞态条件：线程以不一致的顺序访问数据或资源
2. 死锁：两个线程互相等待对方释放资源，导致程序停滞

这些问题在多线程环境中尤为常见，而 Rust 的设计目标就是在编译期就避免这些问题的发生。

Rust 的线程模型

Rust 标准库提供了两种线程模型选择：

1. 1:1 模型（原生线程模型）：

   • 每个语言线程对应一个操作系统线程
   • 标准库默认实现
   • 优点：更接近操作系统原生行为，性能可预测

2. M:N 模型（绿色线程）：

   • M 个语言线程运行在 N 个操作系统线程上
   • 需要通过第三方库实现（如 tokio）
   • 优点：更轻量级，适合高并发场景

线程基础操作

Rust 提供了简洁的线程操作原语：

创建线程

use std::thread;

let handle = thread::spawn(|| {
    // 线程执行的代码
});

等待线程完成

handle.join().unwrap();

线程所有权转移

使用 move 关键字将变量所有权转移到线程中：

let v = vec![1, 2, 3];

let handle = thread::spawn(move || {
    println!("Vector: {:?}", v);  // v 的所有权已转移
});

// 这里不能再使用 v
handle.join().unwrap();

如果不使用 move，编译器会阻止可能导致悬垂引用的代码，这是 Rust 安全并发的重要保障。

线程间通信：消息传递

Rust 采用"不要通过共享内存来通信，而要通过通信来共享内存"的理念，提供了通道(channel)机制：

use std::sync::mpsc;  // 多生产者单消费者

let (tx, rx) = mpsc::channel();

thread::spawn(move || {
    tx.send("消息".to_string()).unwrap();
});

let received = rx.recv().unwrap();
println!("收到: {}", received);

通道的特性：

• 多生产者，单消费者(mpsc)
• 发送端(tx)和接收端(rx)
• 当任一端被丢弃时，通道自动关闭
• 发送操作会转移所有权，确保线程安全

共享状态并发

虽然消息传递是首选，但 Rust 也支持通过互斥锁(Mutex)共享内存：

use std::sync::{Mutex, Arc};

let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];

for _ in 0..10 {
    let counter = Arc::clone(&counter);
    let handle = thread::spawn(move || {
        let mut num = counter.lock().unwrap();
        *num += 1;
    });
    handles.push(handle);
}

for handle in handles {
    handle.join().unwrap();
}

println!("结果: {}", *counter.lock().unwrap());  // 输出 10

关键点：

• Arc<T>：原子引用计数，线程安全的智能指针
• Mutex<T>：提供内部可变性，保证线程安全访问
• 必须显式获取和释放锁
• Rust 的类型系统确保你不会忘记加锁

Sync 和 Send 特质

Rust 通过两个标记特质(marker trait)来保证并发安全：

1. Send：

   • 表示类型的所有权可以在线程间安全转移
   • 大多数 Rust 类型都是 Send
   • 例外：如 Rc 不是 Send

2. Sync：

   • 表示类型的引用可以安全地在多个线程间共享
   • 类型 T 是 Sync 当且仅当 &T 是 Send
   • 例如：Mutex 是 Sync

这些特质由编译器自动推导，也可以手动实现（需确保线程安全）。

总结

Rust 的并发模型提供了：

1. 安全性：编译时检查避免了数据竞争
2. 灵活性：支持消息传递和共享内存两种模式
3. 高效性：零成本抽象，性能接近底层实现

通过本章学习，开发者可以掌握 Rust 中安全高效的并发编程方法，充分利用多核处理器的计算能力，而不用担心常见的并发陷阱。