Arc<Mutex<T>> 模式
面试题
请解释 Rust 中 Arc<Mutex<T>> 的使用模式,为什么需要同时使用 Arc 和 Mutex?有哪些替代方案?
考察意图
Arc<Mutex<T>> 是 Rust 多线程共享可变数据的标准模式。面试官想看候选人能否解释 Arc(共享所有权)和 Mutex(互斥访问)各自的职责、为什么缺一不可,以及何时选择其他替代方案(如 RwLock、Atomic、channel)。
答题要点
为什么需要 Arc + Mutex
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 的使用细节
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!("锁已被其他线程持有");
}
}死锁预防
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>(只读) | 多线程只读共享 | 无锁开销 | 不能修改 |
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 的哲学:"不要通过共享内存来通信,而要通过通信来共享内存"。
基本示例
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。性能优化关注锁竞争和锁粒度。