Rust - 线程 - 技术栈

在计算机科学里，线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一台支持多线程的计算机，其中央处理器（CPU）能够在同一时间内处理多个线程，进而显著提升系统的整体性能。

Rust 的线程设计遵循「内存安全 + 高性能」原则，通过所有权系统和类型系统在编译期防止并发问题。以下是核心概念和 API 的极简总结：

1. 基础概念

线程（Thread） 操作系统调度的最小执行单元，Rust 通过 std::thread 模块创建和管理。
所有权规则不变 每个值仍只有一个所有者，但可通过 move 闭包或智能指针转移所有权到线程。

2. 创建线程

rust 复制代码

use std::thread; 
fn main() { 
    // 创建线程，返回 JoinHandle 
    let handle = thread::spawn(|| { println!("子线程运行中"); }); 
    // 主线程继续执行... 
    // 等待子线程结束 
    handle.join().unwrap(); 
}

3. 线程间通信

通道（Channel）

多生产者单消费者（MPSC）模式：

rust 复制代码

use std::sync::mpsc; 
let (tx, rx) = mpsc::channel(); 
// 发送端可克隆（多生产者） 
let tx1 = tx.clone(); 
thread::spawn(move || { tx1.send("消息1").unwrap(); }); 
// 接收端阻塞等待 println!("收到: {}", rx.recv().unwrap());

4. 共享状态

互斥锁（Mutex）

rust 复制代码

use std::sync::{Mutex, Arc}; 
let data = Arc::new(Mutex::new(0)); // 原子引用计数 + 互斥锁 
// 在线程间克隆 Arc 
let data_clone = Arc::clone(&data); 
thread::spawn(move || { 
    let mut num = data_clone.lock().unwrap(); 
    *num += 1; // 自动释放锁 
});

读写锁（RwLock）

允许多读单写：

rust 复制代码

let lock = Arc::new(RwLock::new(0)); 
// 读锁（允许多个） 
let read = lock.read().unwrap(); 
// 写锁（独占） 
let mut write = lock.write().unwrap();

5. 原子操作

无锁并发，适用于计数器等场景：

rust 复制代码

use std::sync::atomic::{AtomicUsize, Ordering}; 
let counter = Arc::new(AtomicUsize::new(0)); 
// 原子加1 
counter.fetch_add(1, Ordering::SeqCst);

6. 线程安全标记

Rust 通过以下两个自动实现的 trait 确保线程安全：

Send 类型可安全地在线程间转移所有权（如 i32, String）。
Sync 类型的引用可安全地在线程间共享（如 Mutex<T>）。

7. 常见模式

消息传递：用通道替代共享状态。
共享状态 ：Arc<Mutex<T>> 或 Arc<RwLock<T>>。
无锁并发：原子类型（性能更高）。

总结 Rust 线程的核心优势：

编译期安全：所有权和类型系统强制线程安全。
零成本抽象：高性能，无需垃圾回收。
死锁预防：通过 RAII 自动释放锁。