Rust - 互斥锁

在 Rust 中，互斥锁（Mutex）是一种用于实现线程同步的机制，可防止多个线程同时访问共享资源，从而避免数据竞争（Data Race）。Rust 的类型系统和所有权机制确保了 Mutex 的使用是安全的，错误使用会在编译时被捕获。

1. 互斥锁是什么？

想象你和几个朋友共用一台打印机：

• 问题：如果大家同时发送打印任务，打印内容会混在一起
• 解决方案：在打印机上放一个"使用中"牌子
• 互斥锁就像这个牌子 ：
  • 当你想打印时，先拿起牌子（获取锁）
  • 打印完成后再放回牌子（释放锁）
  • 其他人看到牌子被拿走，就会等待

在编程中，互斥锁保护的是共享数据（比如打印机），确保同一时间只有一个线程访问它。

2. Rust 互斥锁的基本使用

第一步：创建互斥锁

use std::sync::Mutex;

// 创建一个保护整数的互斥锁
let printer = Mutex::new(0); // 初始值设为0

第二步：获取锁

{
    // 获取锁 - 相当于拿起"使用中"牌子
    let mut lock_guard = printer.lock().unwrap();
    
    // 现在可以安全地修改数据
    *lock_guard += 1; // 增加计数器
} // 这里 lock_guard 离开作用域，自动释放锁

第三步：读取数据

{
    // 再次获取锁来读取数据
    let count = printer.lock().unwrap();
    println!("当前计数: {}", *count);
} // 自动释放锁

3. 多线程中使用

当多个线程需要共享同一个数据时：

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

// 创建可共享的互斥锁（Arc 就像团队共享名单）
let counter = Arc::new(Mutex::new(0));
let mut threads = vec![];

for _ in 0..5 {
    // 为每个线程创建共享所有权的副本
    let counter_clone = Arc::clone(&counter);
    
    let thread = thread::spawn(move || {
        // 线程内部获取锁
        let mut num = counter_clone.lock().unwrap();
        *num += 1; // 安全地修改数据
        
        println!("线程增加计数");
    });
    
    threads.push(thread);
}

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

// 查看最终结果
let result = counter.lock().unwrap();
println!("最终计数: {}", *result); // 输出: 最终计数: 5

4. 锁的自动释放机制

Rust 互斥锁最聪明的地方在于自动释放机制：

{
    let guard = printer.lock().unwrap(); // 获取锁
    // 在这里操作数据...
} // 当 guard 变量离开这个花括号范围时，锁自动释放！

这就像你拿着"使用中"牌子去打印：

• 不需要记住什么时候放回牌子
• 当你离开打印区（作用域结束），牌子自动回到原位

5. 锁中毒：当线程崩溃时

如果线程在持有锁时崩溃了怎么办？

let data = Arc::new(Mutex::new(42));

let data_clone = Arc::clone(&data);
thread::spawn(move || {
    let _guard = data_clone.lock().unwrap();
    panic!("哎呀，崩溃了！"); // 此时还持有锁
});

// 在主线程中处理
match data.lock() {
    Ok(guard) => println!("数据是正常的: {}", *guard),
    Err(poisoned) => {
        // 锁中毒了，但我们可以恢复数据
        let recovered_data = poisoned.into_inner();
        println!("恢复后的数据: {}", recovered_data);
    }
}

6. 避免死锁的实用技巧

死锁就像两个人互相等待对方放回牌子：

// 线程1
lock_a.lock();
lock_b.lock(); // 等待线程2释放lock_b

// 线程2
lock_b.lock();
lock_a.lock(); // 等待线程1释放lock_a

解决方案：

1. 按顺序获取锁：所有线程都先获取A再获取B
2. 缩小锁范围：尽快释放不需要的锁
3. 使用 try_lock：尝试获取锁，如果失败就做其他事

// 更好的方式 - 按固定顺序获取锁
fn safe_update(a: &Mutex<i32>, b: &Mutex<i32>) {
    let _guard_a = a.lock().unwrap();
    // 在这里处理与a相关的任务...
    
    {
        let _guard_b = b.lock().unwrap();
        // 处理需要a和b的任务...
    } // 先释放b的锁
    
    // 继续处理a...
} // 最后释放a

7. 互斥锁 vs 读写锁（RwLock）

场景	互斥锁 (Mutex)	读写锁 (RwLock)
多个读取者	每次只能一个线程访问	允许多个线程同时读取
单个写入者	需要独占访问	需要独占访问
最佳适用场景	读写频率相当	读多写少
使用示例	银行账户余额	网站访问计数器

8. 日常开发中的最佳实践

1. 锁保护最小数据原则：只把真正需要共享的数据放在锁里

   // 好：只保护共享数据
   let shared_data = Mutex::new(MyData);
   
   // 不好：把整个结构都锁起来
   struct Everything {
       shared: i32,
       local: String, // 这个不需要共享！
   }
   let bad = Mutex::new(Everything { ... });

2. 避免在锁内执行耗时操作：

   let lock = data.lock().unwrap();
   // 快速操作
   *lock += 1;
   
   // 不要这样做！
   // download_large_file(); // 这会阻塞所有其他线程

3. 考虑替代方案：对于简单场景，通道 (channel) 可能更简单

   use std::sync::mpsc;
   
   let (sender, receiver) = mpsc::channel();
   
   thread::spawn(move || {
       sender.send(42).unwrap();
   });
   
   println!("收到: {}", receiver.recv().unwrap());

9. 常见问题

Q: 什么时候该用互斥锁？ A: 当你有多线程需要修改同一个数据时。

Q: lock() 和 try_lock() 有什么区别？ A:

• lock() 会等待直到获取锁
• try_lock() 立即返回，获取不到锁也不会等待

Q: 为什么我的程序变慢了？ A: 可能是因为：

1. 锁的范围太大（持有锁时间太长）
2. 太多线程竞争同一个锁
3. 在锁内执行了耗时操作

Q: 如何调试死锁？ A: 可以：

1. 使用 RUST_BACKTRACE=1 运行程序
2. 检查锁的获取顺序
3. 使用专门的并发调试工具