Rust 并发编程（实战总结）

Rust 并发编程：从入门到掌握

在现代软件开发中，并发编程早已不是“高级特性”，而是构建高性能应用的必备技能。无论是 Web 服务处理大量请求，还是数据处理任务并行执行，都离不开并发的支持。而 Rust 语言凭借其独特的所有权系统和零成本抽象，让并发编程变得既安全又高效。今天，我们就来一起深入探索 Rust 并发编程的核心机制，帮助你从初学者进阶为能写出可靠并发代码的开发者。

Rust 并发编程的最大优势在于——它在编译期就帮你消灭了绝大多数并发错误，比如数据竞争（data race）。这在其他语言中往往是运行时才暴露的问题，而 Rust 通过类型系统和所有权规则，让你“写错了就编译不过”，从根源上杜绝隐患。

线程的创建与基本使用

在 Rust 中，创建线程最直接的方式是使用 std::thread::spawn 函数。它接受一个闭包作为参数，该闭包会在新线程中执行。

use std::thread;

fn main() {
    // 创建一个新线程，执行一个简单的打印任务
    let handle = thread::spawn(|| {
        println!("Hello from a new thread!");
    });

    // 主线程继续执行
    println!("Hello from the main thread!");

    // 等待新线程结束，避免主线程提前退出
    handle.join().unwrap();
}

代码注释说明：

• thread::spawn 返回一个 JoinHandle，它代表了新线程的句柄。
• join() 方法会阻塞当前线程，直到子线程执行完毕。如果没有调用 join()，主线程可能在子线程完成前就退出了，导致子线程被中断。
• unwrap() 用于处理可能的错误，比如线程崩溃时会返回 Err。

💡 小比喻：你可以把线程想象成多个工人。主线程是项目经理，spawn 就是派一个工人去干活，join 就是等这个工人完成任务后再继续下一步。如果项目经理不等工人，任务可能还没做完就收工了。

共享数据的挑战与解决方案

当你想让多个线程访问同一个变量时，问题就来了：如果两个线程同时读写同一个内存位置，就可能引发数据竞争。Rust 的编译器会直接阻止这种行为，哪怕你写得“看起来对”。

使用 Arc<T> 实现共享引用

Arc 是 “Atomic Reference Counting” 的缩写，它是一种线程安全的引用计数智能指针。当多个线程需要共享不可变数据时，Arc<T> 是首选。

use std::sync::Arc;
use std::thread;

fn main() {
    // 创建一个共享的字符串数据
    let data = Arc::new("Hello, Rust!".to_string());

    // 创建 3 个线程，每个都使用同一个数据
    let mut handles = vec![];

    for i in 0..3 {
        // 克隆 Arc，不会复制数据，只是增加引用计数
        let data_clone = Arc::clone(&data);

        let handle = thread::spawn(move || {
            // 每个线程打印自己的 ID 和共享数据
            println!("Thread {} says: {}", i, data_clone);
        });

        handles.push(handle);
    }

    // 等待所有线程结束
    for handle in handles {
        handle.join().unwrap();
    }
}

代码注释说明：

• Arc::clone(&data) 是轻量级操作，不会深拷贝字符串，只是增加引用计数。
• move 关键字将 data_clone 移动到闭包中，确保线程拥有数据所有权。
• 因为 Arc<T> 是不可变共享，所以多个线程可以安全地读取同一个 String。

✅ 适用场景：只读共享数据，如配置文件、常量、缓存等。

可变共享数据：使用 Mutex<T>

如果多个线程需要修改共享数据，仅靠 Arc<T> 不够，因为 Arc 只支持不可变访问。这时需要配合 Mutex<T>（互斥锁）来实现线程安全的可变共享。

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

fn main() {
    // 创建一个可变的共享计数器
    let counter = Arc::new(Mutex::new(0));

    let mut handles = vec![];

    // 创建 5 个线程，每个都对计数器加 1
    for _ in 0..5 {
        let counter_clone = Arc::clone(&counter);

        let handle = thread::spawn(move || {
            // 获取锁，进入临界区
            let mut num = counter_clone.lock().unwrap();
            *num += 1; // 修改共享数据
        });

        handles.push(handle);
    }

    // 等待所有线程完成
    for handle in handles {
        handle.join().unwrap();
    }

    // 最后打印最终值
    let final_value = counter.lock().unwrap();
    println!("Final counter value: {}", *final_value);
}

代码注释说明：

• Mutex::new(0) 创建一个初始值为 0 的互斥锁。
• lock() 方法返回一个 MutexGuard，它是一个临时的独占引用，只有持有它时才能修改数据。
• unwrap() 用于处理锁获取失败的情况（比如锁被死锁，但这种情况在合理使用下极少发生）。
• 一旦 MutexGuard 超出作用域（比如闭包结束），锁会自动释放，其他线程就能继续获取。

⚠️ 注意：Mutex 是独占的，所以多个线程必须排队获取锁，这可能成为性能瓶颈。适合频繁修改但总量不大的数据。

通道（Channels）：线程间通信的理想方式

如果说共享内存是“多个工人共用一个工具箱”，那么通道就是“工人之间通过传纸条沟通”。在 Rust 中，std::sync::mpsc 模块提供了多生产者单消费者（Multi-Producer, Single-Consumer）通道，是线程间通信的首选方案。

use std::sync::mpsc;
use std::thread;

fn main() {
    // 创建一个通道，返回发送端和接收端
    let (tx, rx) = mpsc::channel();

    // 创建一个线程，发送数据
    let sender = thread::spawn(move || {
        let messages = vec!["Hello", "from", "a", "thread!"];

        for msg in messages {
            tx.send(msg.to_string()).unwrap();
            thread::sleep(std::time::Duration::from_millis(200));
        }
    });

    // 主线程接收数据
    for received in rx {
        println!("Received: {}", received);
    }

    // 等待发送线程结束
    sender.join().unwrap();
}

代码注释说明：

• mpsc::channel() 返回一个 (Sender<T>, Receiver<T>) 对组，Sender 用于发送，Receiver 用于接收。
• send() 方法会阻塞，直到接收方准备好。
• rx 是一个迭代器，可以直接用 for 循环消费所有消息。
• 当所有 Sender 被丢弃时，Receiver 会结束迭代，避免死循环。

🔄 优势：避免了锁竞争，通信更清晰，适合“生产-消费”模型，如日志处理、任务队列等。

无锁并发：atomic 原子操作

对于某些高性能场景，比如计数器、标志位等，我们甚至可以不使用 Mutex 或 Arc，而是使用原子操作。Rust 提供了 std::sync::atomic 模块，支持对基本类型进行原子读写。

use std::sync::atomic::{AtomicUsize, Ordering};
use std::thread;

fn main() {
    let counter = AtomicUsize::new(0);

    let mut handles = vec![];

    // 创建 10 个线程，每个都原子性地加 1000
    for _ in 0..10 {
        let counter_clone = &counter;

        let handle = thread::spawn(move || {
            for _ in 0..1000 {
                counter_clone.fetch_add(1, Ordering::SeqCst);
            }
        });

        handles.push(handle);
    }

    // 等待所有线程完成
    for handle in handles {
        handle.join().unwrap();
    }

    println!("Final count: {}", counter.load(Ordering::SeqCst));
}

代码注释说明：

• AtomicUsize 是一个原子无符号整数类型，支持原子操作。
• fetch_add(1, Ordering::SeqCst) 表示“原子地加 1”，并返回旧值。
• Ordering::SeqCst 表示“顺序一致性”，是最严格的内存顺序，保证所有线程看到的操作顺序一致。
• 无需锁，性能更高，适合高并发计数场景。

🔍 适用场景：计数器、标志位、状态管理等，对性能要求极高且操作简单的情况。

实用建议与最佳实践

在实际项目中，合理选择并发模式至关重要。以下是一些经验总结：

📌 小贴士：优先考虑通道通信，避免共享可变状态。如果必须共享数据，尽量使用 Arc<Mutex<T>>，并控制锁的持有时间。

结语

Rust 并发编程的魅力在于：它不牺牲性能，也不降低安全性。通过所有权系统、智能指针和原子操作的巧妙组合，Rust 让你既能写出高性能的并发代码，又能避免常见的并发陷阱。无论你是刚接触多线程的新手，还是希望提升并发编程能力的中级开发者，掌握 Rust 的并发模型都将是一次值得的投资。

从 spawn 开始，到 Arc、Mutex、通道和原子操作，每一步都在构建一个更安全、更高效的并发系统。当你能在编译期就发现数据竞争问题时，那种“代码写得对，跑得稳”的自信，正是 Rust 带给开发者的独特体验。

现在，拿起你的编辑器，试试写一个真正安全的并发程序吧。