1. Rust 多线程编程的基础：标准库 std::thread

Rust 的并发编程能力根植于其标准库，其中 std::thread 模块是实现多线程的基石。它提供了创建和管理原生操作系统线程的基本工具。

1.1. 线程的创建与执行：thread::spawn

创建新线程的核心函数是 std::thread::spawn() 。该函数接受一个闭包（closure）作为参数，这个闭包包含了新线程需要执行的代码逻辑。

在实现rust的多线程编程中重要的一点是：与 spawn 一同使用 move 关键字。move 会强制闭包获取其所使用外部变量的所有权。这一点至关重要，因为它能防止主线程和子线程同时拥有对同一数据的所有权，从而在编译阶段就避免了潜在的数据竞争和悬垂指针问题。

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

// 示例：创建一个新线程
fn basic_thread_creation() {
    let handle = thread::spawn(move || {
        for i in 1..5 {
            println!("子线程计数: {}", i);
            thread::sleep(Duration::from_millis(1)); // 暂停线程，防止其过快结束
        }
    });

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

1.2 等待线程完成：JoinHandle 与 join 方法

thread::spawn() 函数会返回一个 JoinHandle 类型的句柄。这个句柄代表了被创建的子线程。通过调用其上的 join() 方法，主线程可以阻塞自身，直到对应的子线程执行完毕。

join() 方法返回一个 Result，如果子线程成功执行完毕，它会返回 Ok，其中包含子线程闭包的返回值；如果子线程在执行过程中发生了 panic，它会返回 Err。这是一种捕获子线程异常和获取其计算结果的重要机制。

// 示例：等待线程完成并获取返回值
fn waiting_for_thread() {
    let handle = thread::spawn(move || {
        // ... 执行一些计算
        "子线程执行完毕"
    });

    // 等待子线程结束
    let result = handle.join().unwrap();
    println!("主线程收到: {}", result);
}

通过组合使用 spawn 和 join，我们可以构建出基础的并行执行模式，即“分叉-连接”（Fork-Join）模型。

2. 核心安全保障：Send 与 Sync Trait

Rust “无畏并发”的底气源自其两个核心的标记 trait（marker traits）：Send 和 Sync。它们是 Rust 并发安全模型的基石，通过在编译时进行静态检查，彻底杜绝了数据竞争。

• Send Trait: 如果一个类型实现了 Send，意味着该类型的所有权可以被安全地从一个线程 发送（Send）‍ 到另一个线程。Rust 中绝大多数基础类型和标准库类型（如 String, Vec< T >, Box< T >）都默认实现了 Send。一个著名的反例是 Rc< T >（引用计数指针），它并非线程安全的，因此没有实现 Send，编译器会阻止你将其所有权转移到另一个线程。

• Sync Trait: 如果一个类型实现了 Sync，意味着该类型的不可变引用 &T 可以被安全地在多个线程之间 同步（Synchronously）‍ 共享。一个重要的推论是：如果 &T 实现了 Send，那么 T 就实现了 Sync。例如，Mutex< T > 本身实现了 Sync，允许其引用 &Mutex< T > 在线程间共享，但 Mutex 本身并不一定实现 Send。

3. 线程间通信与状态共享

在多线程编程中，线程之间是需要协作。Rust 提供了两种主要的协作模式：共享内存和消息传递。

3.1. 共享可变状态：Arc 与 Mutex 的黄金组合

当多个线程需要访问和修改同一份数据时，就需要使用同步原语来保证操作的原子性和互斥性。直接在多线程间共享可变状态是数据竞争的根源，而 Rust 提供了 Arc<Mutex< T >> 这一经典模式来安全地解决此问题。

• Arc< T > (Atomically Reference Counted) ：这是一个线程安全的智能指针，它通过原子操作来管理引用计数。当需要在多个线程之间共享数据所有权时，Arc< T > 是不二之选 。与非线程安全的 Rc< T> 不同，Arc< T> 实现了 Send 和 Sync。

• Mutex< T > (Mutual Exclusion)：互斥锁，它确保在任意时刻，只有一个线程能访问其内部包裹的数据。当一个线程想要访问数据时，它必须先调用 lock() 方法获取锁。如果锁已被其他线程持有，当前线程将被阻塞。当 lock() 返回的 MutexGuard 离开其作用域时，锁会自动被释放。

通过将 Mutex 包装在 Arc 中，即 Arc<Mutex< T >>，我们就可以创建一个可以被多个线程安全共享、并且内部数据可以被互斥修改的结构。

示例：多线程共享计数器

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

fn main() {
    // 1. 创建一个被 Arc 和 Mutex 包装的共享状态
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    // 2. 创建10个线程
    for _ in 0..10 {
        // 3. 为每个线程克隆 Arc，增加引用计数
        let counter_clone = Arc::clone(&counter);
        
        // 4. 创建线程，并使用 move 将克隆的 Arc 移入闭包
        let handle = thread::spawn(move || {
            // 5. 在线程内部，获取互斥锁
            // .lock() 返回一个 Result，我们用 .unwrap() 处理它
            let mut num = counter_clone.lock().unwrap();

            // 6. 对受保护的数据进行修改
            *num += 1;
            
            // 7. 当 `num` (MutexGuard) 离开作用域时，锁会自动释放
        });
        handles.push(handle);
    }

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

    // 9. 在主线程中打印最终结果
    // 此时只有一个所有者（主线程），可以直接获取锁查看结果
    println!("最终结果: {}", *counter.lock().unwrap());
}

3.2 消息传递：通道 (Channels)

除了共享状态，Rust 还大力推崇“消息传递”的并发模型，其理念是“不要通过共享内存来通信，而要通过通信来共享内存”。标准库 std::sync::mpsc 提供了一种实现方式。（不知道为什么想到了kafka这些消息中间件）

• std::sync::mpsc: mpsc 代表“多生产者，单消费者”（multiple producer, single consumer）。你可以创建多个发送端（Sender），但只能有一个接收端（Receiver） 。这适用于任务分发等场景。

• crossbeam-channel: 这是一个功能更强大、性能通常也更优越的第三方库。它提供了多生产者多消费者（MPMC）通道，允许多个发送者和多个接收者同时存在 。此外，它还提供了如 select! 宏（可以同时等待多个通道）等更丰富的功能。

在需要灵活、解耦的线程间通信时，通道是比共享状态更优的选择。