Rust Mutex（互斥锁）

在 Rust 中，Mutex（互斥锁）是用于在多线程环境中保护共享数据的关键同步原语。它通过独占访问机制确保同一时间只有一个线程能访问数据，从而避免数据竞争（Data Race）。以下是 Rust Mutex 的详细用法和核心机制：

1. 基本用法

创建和锁定 Mutex

use std::sync::Mutex;

fn main() {
    let counter = Mutex::new(0); // 创建一个 Mutex，保护初始值为 0

    let mut handles = vec![];

    for _ in 0..5 {
        let handle = std::thread::spawn(move || {
            let mut num = counter.lock().unwrap(); // 获取锁
            *num += 1; // 修改共享数据
        });
        handles.push(handle);
    }

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

    println!("Result: {}", *counter.lock().unwrap()); // 输出: 5
}

• Mutex::new(value)：创建一个 Mutex，保护初始值 value。
• lock()：获取锁，返回 MutexGuard<T>（智能指针），离开作用域时自动释放锁（RAII 机制）。
• unwrap()：如果锁被其他线程 panic 污染（poisoned），lock() 会返回 Err，通常直接 unwrap 处理。

2. 核心机制

（1）锁的获取与释放

• lock() 方法：
  • 如果锁未被占用，当前线程获取锁，返回 MutexGuard<T>。
  • 如果锁已被占用，当前线程阻塞，直到锁可用。
• 自动释放：
  • MutexGuard<T> 实现了 Deref 和 Drop，在离开作用域时自动释放锁，避免忘记解锁。

（2）线程安全保证

• Send + Sync：
  • Mutex<T> 实现了 Send（可安全转移至其他线程）和 Sync（可安全跨线程共享引用）。
  • 但 MutexGuard<T> 仅实现 Send（未实现 Sync），确保锁的独占性。

（3）锁污染（Poisoning）

• 如果持有锁的线程 panic，Mutex 会标记为“中毒”（poisoned），后续 lock() 调用返回 Err。
• 可通过 into_inner() 强制获取数据（即使中毒）：

  let mutex = Mutex::new(42);
  let guard = mutex.lock().unwrap();
  panic!("模拟线程崩溃"); // Mutex 中毒
  drop(guard); // 锁被释放，但状态为中毒
  
  // 另一个线程尝试获取锁
  match mutex.lock() {
      Ok(guard) => println!("正常获取: {}", *guard),
      Err(poisoned) => {
          let data = poisoned.into_inner(); // 强制获取数据
          println!("锁已中毒，但数据可用: {}", *data);
      }
  };
  

3. 常见用法

（1）与 Arc 结合实现多线程共享

Mutex 通常与 Arc（原子引用计数）配合使用，实现多线程共享所有权：

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

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

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

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

    println!("Result: {}", *counter.lock().unwrap()); // 输出: 5
}

（2）避免死锁

• 锁的顺序：确保多个线程以相同的顺序获取锁（如总是先锁 MutexA 再锁 MutexB）。
• try_lock()：非阻塞尝试获取锁，避免死锁：

  if let Ok(mut num) = counter.try_lock() {
      *num += 1;
  } else {
      println!("锁被占用，跳过操作");
  }
  

（3）条件变量（Condvar）

Mutex 可与 Condvar 结合，实现线程间通知机制：

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

fn main() {
    let pair = Arc::new((Mutex::new(false), Condvar::new()));
    let pair_clone = Arc::clone(&pair);

    std::thread::spawn(move || {
        let (lock, cvar) = &*pair_clone;
        let mut started = lock.lock().unwrap();
        *started = true;
        cvar.notify_one(); // 通知等待线程
    });

    let (lock, cvar) = &*pair;
    let mut started = lock.lock().unwrap();
    while !*started {
        started = cvar.wait(started).unwrap(); // 释放锁并等待通知
    }
    println!("子线程已启动！");
}

4. 性能优化

• 减少锁竞争：
  • 缩小临界区（仅锁定必要的代码段）。
  • 使用 RwLock（读写锁）实现读多写少的场景（读操作可并发）。
• 无锁编程：
  • 对简单操作（如计数器），优先使用 Atomic 类型（如 AtomicUsize）。

5. 与 RwLock 的区别

总结

• Mutex 是 Rust 中实现线程安全共享可变数据的核心工具，通过独占访问避免数据竞争。
• 必须与 Arc 结合使用才能在多线程间共享所有权。
• 自动释放锁（RAII）和锁污染处理是 Rust 并发安全的关键设计。
• 优先选择高层抽象（如 channel 或 RwLock）以减少锁竞争。

通过合理使用 Mutex，可以在 Rust 中高效实现安全的并发编程。