Arc<T> 原子引用计数
什么是 Arc<T>
Arc<T> 是 Atomically Reference Counted 的缩写,翻译过来就是"原子引用计数"。它和 Rc<T> 做的事情一样——让多个所有者共享同一份数据的所有权,通过引用计数管理数据的生命周期。区别在于,Arc 的引用计数操作使用了原子指令(atomic operations),所以它可以安全地在多个线程之间共享。
简单来说:Rc<T> 是单线程版本的共享所有权,Arc<T> 是多线程版本的共享所有权。
Arc<T> 定义在 std::sync 模块中,而 Rc<T> 在 std::rc 模块中。这个命名空间的差异就暗示了它们各自的用途——sync 模块里的东西都和线程同步相关。
Arc 和 Rc 的区别
use std::sync::Arc;
use std::rc::Rc;
use std::thread;
fn main() {
// Rc 不能跨线程
let rc_data = Rc::new(42);
// 下面这段代码编译不通过,因为 Rc 没有实现 Send trait
// thread::spawn(move || {
// println!("{}", rc_data);
// });
// Arc 可以跨线程
let arc_data = Arc::new(42);
let arc_clone = Arc::clone(&arc_data);
// Arc 实现了 Send 和 Sync,可以安全地发送到其他线程
let handle = thread::spawn(move || {
println!("另一个线程中的值: {}", arc_clone);
});
println!("主线程中的值: {}", arc_data);
handle.join().unwrap();
}| 对比项 | Rc<T> | Arc<T> |
|---|---|---|
| 引用计数操作 | 普通整数加减 | 原子操作(atomic) |
| 线程安全 | 不安全,只能单线程用 | 安全,可以跨线程 |
| 性能开销 | 更低 | 稍高(原子操作的开销) |
| 所在模块 | std::rc | std::sync |
| 实现 Send | 否 | 是(当 T: Send + Sync) |
| 实现 Sync | 否 | 是(当 T: Send + Sync) |
基本用法
多线程共享不可变数据
use std::sync::Arc;
use std::thread;
fn main() {
// 创建一个 Arc,包含一个大的只读数据集
let data = Arc::new(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
let mut handles = vec![];
// 启动 3 个线程,每个线程都能读取同一份数据
for i in 0..3 {
// Arc::clone 只增加原子引用计数,不复制 Vec 数据
let data_clone = Arc::clone(&data);
let handle = thread::spawn(move || {
// 每个线程计算数据的一部分的和
let start = i * 3;
let end = (start + 3).min(data_clone.len());
let partial_sum: i32 = data_clone[start..end].iter().sum();
println!("线程 {}: 部分和 = {}", i, partial_sum);
});
handles.push(handle);
}
// 等待所有线程完成
for handle in handles {
handle.join().unwrap();
}
// 主线程仍然可以使用 data
println!("主线程: 总和 = {}", data.iter().sum::<i32>());
println!("最终引用计数: {}", Arc::strong_count(&data)); // 1(其他 clone 都已 drop)
}引用计数的变化
use std::sync::Arc;
use std::thread;
fn main() {
let data = Arc::new(String::from("共享字符串"));
println!("初始引用计数: {}", Arc::strong_count(&data)); // 1
let clone1 = Arc::clone(&data);
println!("clone1 后引用计数: {}", Arc::strong_count(&data)); // 2
let handle = thread::spawn(move || {
// clone1 被移动到了这个线程
println!("子线程中的值: {}", clone1);
// 注意:在子线程中也能查看引用计数
// 但因为是原子操作,所以并发访问是安全的
});
// 创建更多克隆
let clone2 = Arc::clone(&data);
println!("clone2 后引用计数: {}", Arc::strong_count(&data)); // 可能是 2 或 3,取决于子线程是否已结束
handle.join().unwrap();
// 子线程结束后,clone1 被 drop,引用计数减少
drop(clone2);
println!("最终引用计数: {}", Arc::strong_count(&data)); // 1
}Arc<Mutex<T>>:跨线程共享可变数据
Arc<T> 本身只提供不可变的共享访问。如果需要在多个线程之间修改共享数据,需要配合同步原语使用。最常见的组合是 Arc<Mutex<T>>。
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
// Arc<Mutex<T>> 是跨线程共享可变数据的标准模式
// Arc 负责共享所有权,Mutex 负责互斥访问
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..10 {
let counter_clone = Arc::clone(&counter);
let handle = thread::spawn(move || {
// lock() 获取锁,返回 MutexGuard
// MutexGuard 实现了 Deref 和 DerefMut,可以像操作内部值一样使用
let mut num = counter_clone.lock().unwrap();
*num += 1;
// MutexGuard 离开作用域时自动释放锁
});
handles.push(handle);
}
// 等待所有线程完成
for handle in handles {
handle.join().unwrap();
}
// 最终结果应该是 10
println!("最终计数: {}", *counter.lock().unwrap());
}Arc<RwLock<T>>:读多写少的场景
当读操作远多于写操作时,RwLock 比 Mutex 更高效。RwLock 允许多个线程同时读取,但写入时需要独占访问。
use std::sync::{Arc, RwLock};
use std::thread;
fn main() {
// 共享配置,读多写少
let config = Arc::new(RwLock::new(AppConfig {
max_connections: 100,
timeout_ms: 3000,
debug_mode: false,
}));
let mut handles = vec![];
// 启动多个读取线程
for i in 0..5 {
let config_clone = Arc::clone(&config);
handles.push(thread::spawn(move || {
// read() 获取读锁,允许多个线程同时持有
let cfg = config_clone.read().unwrap();
println!(
"线程 {} 读取: max_connections = {}, timeout = {}ms",
i, cfg.max_connections, cfg.timeout_ms
);
// 读锁在 cfg 离开作用域时自动释放
}));
}
// 启动一个写入线程
{
let config_clone = Arc::clone(&config);
handles.push(thread::spawn(move || {
// write() 获取写锁,独占访问
let mut cfg = config_clone.write().unwrap();
cfg.debug_mode = true;
cfg.timeout_ms = 5000;
println!("写入线程: 更新了配置");
}));
}
for handle in handles {
handle.join().unwrap();
}
// 读取最终配置
let final_config = config.read().unwrap();
println!(
"最终配置: debug={}, timeout={}ms",
final_config.debug_mode, final_config.timeout_ms
);
}
struct AppConfig {
max_connections: u32,
timeout_ms: u32,
debug_mode: bool,
}Arc::make_mut:写时克隆
Arc::make_mut 提供了一种写时克隆(copy-on-write)的机制。如果当前只有一个 Arc 引用,直接返回可变引用;如果有多个引用,先克隆数据再返回可变引用。
use std::sync::Arc;
fn main() {
let mut data = Arc::new(vec![1, 2, 3]);
println!("引用计数: {}", Arc::strong_count(&data)); // 1
// 只有一个引用时,make_mut 直接给出可变引用,不克隆
Arc::make_mut(&mut data).push(4);
println!("添加 4 后: {:?}", data); // [1, 2, 3, 4]
// 创建一个克隆
let data2 = Arc::clone(&data);
println!("引用计数: {}", Arc::strong_count(&data)); // 2
// 有多个引用时,make_mut 会先克隆数据,然后给出可变引用
// 修改只影响 data,不影响 data2
Arc::make_mut(&mut data).push(5);
println!("data: {:?}", data); // [1, 2, 3, 4, 5]
println!("data2: {:?}", data2); // [1, 2, 3, 4](没有被修改)
println!("引用计数 data: {}", Arc::strong_count(&data)); // 1(已经是新的分配)
}基本示例
一个完整的多线程并行计算示例:
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Instant;
// 并行计算一个大数组中所有元素的平方和
fn parallel_sum_of_squares(data: &[f64], num_threads: usize) -> f64 {
let data = Arc::new(data.to_vec());
let result = Arc::new(Mutex::new(0.0_f64));
let chunk_size = (data.len() + num_threads - 1) / num_threads;
let mut handles = vec![];
for i in 0..num_threads {
let data_clone = Arc::clone(&data);
let result_clone = Arc::clone(&result);
let start = i * chunk_size;
let end = (start + chunk_size).min(data_clone.len());
let handle = thread::spawn(move || {
// 每个线程计算自己负责的那一块数据的平方和
let partial: f64 = data_clone[start..end]
.iter()
.map(|x| x * x)
.sum();
// 把部分结果累加到共享的总结果中
let mut total = result_clone.lock().unwrap();
*total += partial;
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
// 取出最终结果
let final_result = *result.lock().unwrap();
final_result
}
fn main() {
// 生成测试数据
let data: Vec<f64> = (1..=10000).map(|x| x as f64).collect();
// 单线程计算作为对照
let start = Instant::now();
let single_result: f64 = data.iter().map(|x| x * x).sum();
let single_time = start.elapsed();
println!("单线程结果: {:.0}, 耗时: {:?}", single_result, single_time);
// 多线程并行计算
let start = Instant::now();
let parallel_result = parallel_sum_of_squares(&data, 4);
let parallel_time = start.elapsed();
println!("多线程结果: {:.0}, 耗时: {:?}", parallel_result, parallel_time);
// 验证结果一致
println!("结果一致: {}", (single_result - parallel_result).abs() < 0.001);
}常见问题
问题一:什么时候用 Arc,什么时候用 Rc?
规则很简单:数据只在一个线程内使用,用 Rc;数据需要在多个线程之间共享,用 Arc。如果拿不准,用 Arc 不会出错,只是在单线程场景下会有微小的性能浪费。有些库为了让使用者更灵活,会选择默认用 Arc。
问题二:Arc 的原子操作开销到底有多大?
每次 Arc::clone(引用计数加一)和 drop(引用计数减一)都涉及一次原子操作。在现代 CPU 上,一次原子操作大约比普通内存操作慢几倍到几十倍,具体取决于 CPU 架构和缓存状态。对于大多数应用来说这点开销可以忽略,但在每秒数千万次克隆/drop 的极端场景下会产生可观的影响。
问题三:为什么 Arc<T> 需要 T: Send + Sync?
Arc<T> 允许多个线程同时持有对同一份数据的不可变引用。如果 T 不是 Sync(即从多线程通过共享引用访问不安全),那通过 Arc 共享就可能导致数据竞争。Send 约束则保证了 T 可以安全地转移所有权到另一个线程。比如 Rc<T> 不是 Send 也不是 Sync,所以你无法创建 Arc<Rc<T>>——编译器会阻止你把不安全的类型塞进 Arc。
问题四:Arc<Mutex<T>> 和 Arc<RwLock<T>> 怎么选?
| 场景 | 推荐 | 原因 |
|---|---|---|
| 读写频率差不多 | Arc<Mutex<T>> | Mutex 更简单,开销更低 |
| 读多写少 | Arc<RwLock<T>> | 允许多个读者并发读取 |
| 只需要修改简单数值 | Arc<AtomicU64> 等 | 原子类型比 Mutex 更轻量 |
适用场景
- 多线程共享只读数据:配置信息、查找表等在启动时初始化后不再修改的数据
- 多线程共享可变数据:配合
Mutex或RwLock使用,如共享计数器、缓存、任务队列 - 线程池中的共享状态:工作线程之间共享任务队列或结果收集器
- 异步运行时中的共享数据:tokio 等异步框架中,多个 task 之间共享数据
- 跨线程的观察者/订阅模式:事件源需要被多个线程上的监听器共享
注意事项
- 在单线程场景中不要使用
Arc,用Rc更合适,原子操作有不必要的性能开销 Arc本身只提供不可变访问,修改数据需要配合Mutex、RwLock或原子类型- 和
Rc一样,Arc也有循环引用导致内存泄漏的风险,用Weak<T>(Arc::downgrade)打破循环 Arc<Mutex<T>>使用时要注意死锁风险——两个线程互相等待对方释放锁就会死锁Mutex::lock()返回Result,当持有锁的线程 panic 时,锁会进入"中毒"(poisoned)状态,后续lock()返回Err- 避免在持有 Mutex 锁的时候做耗时操作,这会阻塞其他等待锁的线程
Arc::clone的开销虽然比Rc::clone大,但仍然远小于深拷贝数据的开销Arc<T>在栈上占 8 字节(一个指针),堆上除了 T 的数据外还有两个原子计数器(强引用和弱引用各一个)
总结
Arc<T> 是 Rust 中跨线程共享数据的基础工具。它通过原子引用计数实现了多线程环境下的共享所有权,当最后一个 Arc 被 drop 时数据自动释放。和单线程的 Rc<T> 相比,Arc 的代价是原子操作带来的额外开销,但这个开销在大多数场景下微不足道。Arc 本身只提供不可变的共享访问,如果需要修改共享数据,最常用的模式是 Arc<Mutex<T>>(互斥访问)和 Arc<RwLock<T>>(读多写少场景)。在实际并发编程中,Arc 几乎是不可或缺的——无论是线程池、异步任务、还是共享配置,都需要用 Arc 来在多个线程之间安全地共享数据的所有权。