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 的区别 ​

rust
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::rcstd::sync
实现 Send否是(当 T: Send + Sync)
实现 Sync否是(当 T: Send + Sync)

基本用法 ​

多线程共享不可变数据 ​

rust
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)
}

引用计数的变化 ​

rust
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>>。

rust
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 允许多个线程同时读取,但写入时需要独占访问。

rust
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 引用,直接返回可变引用;如果有多个引用,先克隆数据再返回可变引用。

rust
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(已经是新的分配)
}

基本示例 ​

一个完整的多线程并行计算示例:

rust
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 来在多个线程之间安全地共享数据的所有权。