Arc<Mutex<T>> 模式 ​

面试题 ​

请解释 Rust 中 Arc<Mutex<T>> 的使用模式,为什么需要同时使用 Arc 和 Mutex?有哪些替代方案?

考察意图 ​

Arc<Mutex<T>> 是 Rust 多线程共享可变数据的标准模式。面试官想看候选人能否解释 Arc(共享所有权)和 Mutex(互斥访问)各自的职责、为什么缺一不可,以及何时选择其他替代方案(如 RwLock、Atomic、channel)。

答题要点 ​

为什么需要 Arc + Mutex ​

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

fn main() {
    // 多线程共享可变数据需要解决两个问题:
    // 1. 所有权共享 — 多个线程都需要拥有数据的访问权
    //    解决方案:Arc(原子引用计数共享所有权)
    // 2. 互斥访问 — 同一时刻只有一个线程能修改数据
    //    解决方案:Mutex(互斥锁)

    // 只用 Mutex,无法跨线程共享所有权
    // let data = Mutex::new(0);
    // thread::spawn(move || { *data.lock().unwrap() += 1; });
    // thread::spawn(move || { *data.lock().unwrap() += 1; });
    // 编译错误:data 在第一个 spawn 时被 move,第二个无法使用

    // 只用 Arc,无法修改数据
    // let data = Arc::new(0);
    // Arc 只提供 &T(不可变引用),不能修改内部值

    // Arc<Mutex<T>>:两者结合
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);  // 共享所有权
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();  // 互斥访问
            *num += 1;
        });
        handles.push(handle);
    }

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

    println!("最终值: {}", *counter.lock().unwrap());
    // 输出: 最终值: 10
}

Mutex 的使用细节 ​

rust
use std::sync::Mutex;

fn main() {
    let data = Mutex::new(vec![1, 2, 3]);

    // lock() 返回 Result<MutexGuard<T>, PoisonError>
    // MutexGuard 实现了 Deref 和 DerefMut,可以直接操作内部数据
    {
        let mut guard = data.lock().unwrap();
        guard.push(4);
        println!("锁内: {:?}", *guard);
        // guard 离开作用域时自动释放锁(RAII)
    }

    // 锁已释放,可以再次获取
    let guard = data.lock().unwrap();
    println!("再次获取: {:?}", *guard);
    drop(guard);

    // === 中毒(Poisoned)机制 ===
    // 如果持有锁的线程 panic,锁会被"中毒"
    // 后续 lock() 返回 Err(PoisonError)
    // 可以用 .unwrap() 直接 panic,或者恢复数据
    // data.lock().unwrap_or_else(|e| e.into_inner())

    // === try_lock:非阻塞尝试获取锁 ===
    if let Ok(guard) = data.try_lock() {
        println!("try_lock 成功: {:?}", *guard);
    } else {
        println!("锁已被其他线程持有");
    }
}

死锁预防 ​

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

fn main() {
    // === 死锁场景一:同一线程重复加锁 ===
    // Mutex 不是可重入的(非递归锁)
    let data = Mutex::new(42);
    let _guard = data.lock().unwrap();
    // let _guard2 = data.lock().unwrap();  // 死锁:同一线程等待自己释放锁

    drop(_guard);

    // === 死锁场景二:两个锁的交叉等待 ===
    // 线程 A 持有锁1,等待锁2
    // 线程 B 持有锁2,等待锁1
    // 预防方法:所有线程按相同顺序获取锁

    let lock1 = Arc::new(Mutex::new(1));
    let lock2 = Arc::new(Mutex::new(2));

    let l1 = Arc::clone(&lock1);
    let l2 = Arc::clone(&lock2);

    // 两个线程都按 lock1 → lock2 的顺序获取锁
    let h1 = thread::spawn(move || {
        let _g1 = l1.lock().unwrap();
        let _g2 = l2.lock().unwrap();
        println!("线程1: {} {}", *_g1, *_g2);
    });

    let l1 = Arc::clone(&lock1);
    let l2 = Arc::clone(&lock2);

    let h2 = thread::spawn(move || {
        let _g1 = l1.lock().unwrap();  // 同样先获取 lock1
        let _g2 = l2.lock().unwrap();  // 再获取 lock2
        println!("线程2: {} {}", *_g1, *_g2);
    });

    h1.join().unwrap();
    h2.join().unwrap();

    // === 减少锁持有时间 ===
    // 获取锁后尽快释放,避免在锁内做耗时操作
    let data = Arc::new(Mutex::new(vec![1, 2, 3]));
    let data_clone = Arc::clone(&data);
    thread::spawn(move || {
        let value = {
            let guard = data_clone.lock().unwrap();
            guard.clone()  // 复制数据后立即释放锁
        };
        // 耗时处理在锁外进行
        println!("处理: {:?}", value);
    }).join().unwrap();
}

替代方案对比 ​

方案适用场景优点缺点
Arc<Mutex<T>>多线程读写频率相近简单直接读也要加锁
Arc<RwLock<T>>读多写少多个读可并发写锁独占,可能饥饿
AtomicXxx简单数值操作无锁,最高性能只支持基础类型
channel生产者-消费者模式无需共享状态数据复制开销
Arc<T>(只读)多线程只读共享无锁开销不能修改
rust
use std::sync::{Arc, RwLock};
use std::sync::atomic::{AtomicU64, Ordering};
use std::thread;

fn main() {
    // === RwLock:读多写少场景 ===
    let config = Arc::new(RwLock::new(String::from("v1.0")));

    // 多个线程可以同时读
    let c = Arc::clone(&config);
    let reader = thread::spawn(move || {
        let r = c.read().unwrap();
        println!("读取配置: {}", *r);
    });

    // 写入时独占
    let c = Arc::clone(&config);
    let writer = thread::spawn(move || {
        let mut w = c.write().unwrap();
        *w = "v2.0".to_string();
        println!("更新配置: {}", *w);
    });

    reader.join().unwrap();
    writer.join().unwrap();

    // === Atomic:简单数值 ===
    let counter = Arc::new(AtomicU64::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let c = Arc::clone(&counter);
        handles.push(thread::spawn(move || {
            c.fetch_add(1, Ordering::Relaxed);
        }));
    }

    for h in handles { h.join().unwrap(); }
    println!("原子计数: {}", counter.load(Ordering::Relaxed));

    // === Channel:消息传递 ===
    let (tx, rx) = std::sync::mpsc::channel();
    for i in 0..5 {
        let tx = tx.clone();
        thread::spawn(move || {
            tx.send(i * 10).unwrap();
        });
    }
    drop(tx);  // 关闭发送端

    while let Ok(val) = rx.recv() {
        println!("收到: {}", val);
    }
}

常见追问 ​

追问一:MutexGuard 跨 await 点有什么问题?

MutexGuard 不是 Send 的(某些平台要求同线程加锁/解锁)。在 async 函数中持有 MutexGuard 跨 await 点会导致编译错误。解决方案:在 await 前 drop guard,或使用 tokio::sync::Mutex(异步 Mutex)。

追问二:parking_lot 的 Mutex 和标准库的有什么区别?

parking_lot::Mutex 更小(1 字节 vs 标准库的 40+ 字节)、更快(优化的自旋等待)、没有中毒机制。适合性能敏感场景。

追问三:什么时候用 channel 代替 Mutex?

当模式是"一个线程产生数据,另一个线程消费"时用 channel。channel 避免了共享状态的复杂性。Go 的哲学:"不要通过共享内存来通信,而要通过通信来共享内存"。

基本示例 ​

rust
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::thread;

// 线程安全的缓存
struct Cache {
    store: Arc<Mutex<HashMap<String, String>>>,
}

impl Cache {
    fn new() -> Self {
        Cache {
            store: Arc::new(Mutex::new(HashMap::new())),
        }
    }

    fn get(&self, key: &str) -> Option<String> {
        let store = self.store.lock().unwrap();
        store.get(key).cloned()
    }

    fn set(&self, key: String, value: String) {
        let mut store = self.store.lock().unwrap();
        store.insert(key, value);
    }

    fn clone_handle(&self) -> Self {
        Cache {
            store: Arc::clone(&self.store),
        }
    }
}

fn main() {
    let cache = Cache::new();
    let mut handles = vec![];

    // 多个线程并发写入
    for i in 0..5 {
        let c = cache.clone_handle();
        handles.push(thread::spawn(move || {
            c.set(format!("key{}", i), format!("value{}", i));
        }));
    }

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

    // 读取
    for i in 0..5 {
        if let Some(val) = cache.get(&format!("key{}", i)) {
            println!("{}={}", format!("key{}", i), val);
        }
    }
}

常见问题 ​

问题一:Mutex 的性能开销大吗?

锁本身的获取/释放开销很小(无竞争时约几十纳秒)。主要开销来自锁竞争——多个线程同时尝试获取锁时的等待。减少锁持有时间和锁的粒度是优化关键。

问题二:Arc 的引用计数开销大吗?

Arc 的 clone 和 drop 使用原子操作(约几纳秒),比普通整数操作慢但比锁快得多。在大量 clone/drop 的场景下可能成为瓶颈。

适用场景 ​

  • 共享计数器:多线程并发累加
  • 共享缓存:多线程读写缓存数据
  • 共享配置:运行时动态更新配置
  • 连接池:多线程共享有限资源

注意事项 ​

  • Mutex 不是可重入的(同线程重复加锁会死锁)
  • 多个锁按固定顺序获取(避免交叉死锁)
  • 减少锁持有时间
  • 线程 panic 会中毒锁
  • async 中不要跨 await 持有 MutexGuard
  • 读多写少用 RwLock,简单数值用 Atomic

总结 ​

Arc<Mutex<T>> 是 Rust 多线程共享可变数据的标准模式。Arc 提供原子引用计数的共享所有权,Mutex 提供互斥访问保护。lock() 返回 MutexGuard(RAII 自动释放锁)。需要注意死锁预防(不重复加锁、固定获取顺序、减少持有时间)和锁中毒处理。替代方案:RwLock 适合读多写少,Atomic 适合简单数值操作,channel 适合生产者-消费者模式。async 代码中用 tokio::sync::Mutex 替代标准库 Mutex。性能优化关注锁竞争和锁粒度。