`Arc` 是 Rust 中用于**线程安全共享所有权**的核心智能指针，全称 **Atomically Reference Counted**（原子引用计数）。在多线程编程中，当你需要在多个线程之间安全共享同一份数据时，`Arc` 是最常用、最可靠的工具。

本文将从基础概念到高级用法、性能实践和注意事项，系统讲解 `Arc`，帮助你快速掌握 Rust 并发共享数据的核心技巧。

---

## 1. 什么是 `Arc`？

`std::sync::Arc<T>` 允许多个线程安全地共享堆上同一份数据。它通过原子操作维护引用计数，当所有 `Arc` 实例都被释放后，内部数据才会被自动 drop。

**核心优势**：
- 线程安全（`Send + Sync`，前提 `T: Send + Sync`）
- 不复制数据，仅增加引用计数
- 与 `Mutex`、`RwLock` 等结合，实现线程安全的可变共享

### `Arc` 与 `Rc` 的对比

| 特性       | `Rc<T>` (`std::rc`)          | `Arc<T>` (`std::sync`)                  |
|------------|------------------------------|-----------------------------------------|
| 线程安全   | ❌ 单线程专用                | ✅ 线程安全（依赖原子操作）             |
| 计数方式   | 普通整数（更快）             | `AtomicUsize`（稍有开销，但现代 CPU 上差距很小） |
| 使用场景   | 单线程、GUI、单线程异步      | 多线程、Tokio、并发服务                 |

**结论**：单线程优先使用 `Rc`，跨线程必须使用 `Arc`。

---

## 2. 基础用法

### 2.1 引入与基本共享

```rust
use std::sync::Arc;
use std::thread;

fn main() {
    let data = Arc::new(String::from("Hello, Arc!"));

    let mut handles = vec![];
    for i in 0..5 {
        // 推荐写法：使用 Arc::clone，语义更清晰
        let data_clone = Arc::clone(&data);
        let handle = thread::spawn(move || {
            println!("线程 {}: {}", i, data_clone);
        });
        handles.push(handle);
    }

    // 必须等待所有线程完成，否则主线程提前退出会导致子线程被终止
    for h in handles {
        h.join().unwrap();
    }

    println!("主线程: {}", data);
}
```

**最佳实践**：始终使用 `Arc::clone(&arc)` 而非 `arc.clone()`，能更清晰地表达"仅增加引用计数"的意图。

### 2.2 共享可变数据：`Arc` + `Mutex` / `RwLock`

`Arc<T>` 本身只提供不可变引用。要修改共享数据，必须结合内部可变性机制：

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

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let c = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut guard = c.lock().unwrap();
            *guard += 1;
            // guard 在此处 drop，自动释放锁
        });
        handles.push(handle);
    }

    // 等待所有线程完成，确保计数器已更新
    for h in handles {
        h.join().unwrap();
    }

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

**推荐组合**：
- `Arc<Mutex<T>>` —— 通用场景
- `Arc<RwLock<T>>` —— 读多写少场景（更高并发性能）
- `Arc<AtomicUsize>` —— 基本类型，性能最佳

> **关于 `RefCell`**：`RefCell<T>` 不满足 `Sync`，因此 `Arc<RefCell<T>>` 无法跨线程使用——编译器会直接拒绝。单线程场景请使用 `Rc<RefCell<T>>`。

---

## 3. 高级用法

### 3.1 读写分离：结合 `RwLock`

```rust
use std::sync::{Arc, RwLock};
use std::thread;

fn main() {
    let data = Arc::new(RwLock::new(String::from("Initial")));
    let mut handles = vec![];

    // 多个读线程
    for i in 0..3 {
        let d = Arc::clone(&data);
        let handle = thread::spawn(move || {
            let read_guard = d.read().unwrap();
            // 注意：由于并发执行，读者可能读到 "Initial" 也可能读到 "Modified"
            println!("Reader {}: {}", i, *read_guard);
        });
        handles.push(handle);
    }

    // 写线程
    {
        let d = Arc::clone(&data);
        let handle = thread::spawn(move || {
            let mut write_guard = d.write().unwrap();
            *write_guard = String::from("Modified");
            println!("Writer: 数据已修改");
        });
        handles.push(handle);
    }

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

> **注意**：由于读写线程并发执行，读者可能读到 `"Initial"` 也可能读到 `"Modified"`，这取决于线程调度顺序。`RwLock` 保证的是"写者互斥、读写互斥、读者之间共享"，但不保证特定的执行顺序。

### 3.2 动态分发：`Arc<dyn Trait + Send + Sync>`

适合需要共享 trait object 的场景：

```rust
use std::sync::Arc;

trait Worker: Send + Sync {
    fn work(&self);
}

struct MyWorker;

impl Worker for MyWorker {
    fn work(&self) {
        println!("Working hard!");
    }
}

fn main() {
    let worker: Arc<dyn Worker> = Arc::new(MyWorker);
    // 可在多个线程中克隆使用
    let w1 = Arc::clone(&worker);
    let w2 = Arc::clone(&worker);
}
```

### 3.3 弱引用 `Weak` —— 打破循环引用

```rust
use std::sync::{Arc, Weak};

#[derive(Debug)]
struct Node {
    value: i32,
    parent: Weak<Node>,        // 使用 Weak 避免循环引用
    children: Vec<Arc<Node>>,
}

fn main() {
    // 推荐使用 new_cyclic 构造自引用结构
    let root = Arc::new_cyclic(|weak_parent| Node {
        value: 42,
        parent: weak_parent.clone(),
        children: vec![],
    });

    println!("根节点值: {}", root.value);
    println!("强引用计数: {}", Arc::strong_count(&root)); // 1
    println!("弱引用计数: {}", Arc::weak_count(&root));   // 1（来自 parent 字段）
}
```

- `Arc::downgrade(&arc)` —— 创建 `Weak` 引用
- `weak.upgrade()` —— 返回 `Option<Arc<T>>`，若数据已被释放则返回 `None`

> ⚠️ 深度警示：Weak 与内存“悬挂”陷阱
>   - 虽然 Weak 不增加强引用计数，能让内部的 T 被正常 drop，但它会阻止整块堆内存的释放。
>   - 原理：Arc 内部的数据和两个计数器（Strong/Weak）通常分配在同一块内存中。只有当强引用计数 和 弱引用计数都归零时，这块堆内存才会真正还给操作系统。
>   - 风险：如果你共享了一个巨大的数据（如 Arc<[u8; 1GB]>），即便强引用全部释放，只要还有一个长周期的 Weak 引用存在，这 1GB 的内存“空壳”就会一直残留在堆上。
>   - 对策：不要在长生命周期的全局变量中长期持有指向大数据块的 Weak 引用。

> **适用场景**：双向树（带父指针）、有环图等可能产生循环引用的结构，必须用 `Weak` 打破循环，否则会导致内存泄漏。单向树结构不存在循环引用，无需使用 `Weak`。

### 3.4 全局共享状态：`Arc` + `OnceLock` / `LazyLock`

Rust 1.70 引入了 `OnceLock`，1.80 引入了 `LazyLock`，它们与 `Arc` 搭配非常适合管理全局共享的不可变配置：

```rust
use std::sync::{Arc, LazyLock};

struct AppConfig {
    db_url: String,
    max_connections: u32,
}

impl AppConfig {
    fn load() -> Self {
        // 模拟从环境变量或配置文件加载
        AppConfig {
            db_url: "postgres://localhost/mydb".to_string(),
            max_connections: 100,
        }
    }
}

// 全局懒加载配置，线程安全，只初始化一次
static CONFIG: LazyLock<Arc<AppConfig>> = LazyLock::new(|| {
    Arc::new(AppConfig::load())
});

fn main() {
    // 多个线程安全地访问同一份配置
    println!("DB URL: {}", CONFIG.db_url);
}
```

**优势**：无需手动管理初始化时序，`LazyLock` 保证线程安全的懒加载，`Arc` 允许各处低成本克隆引用。

---

## 4. 实用高级 API

| API | 说明 |
|-----|------|
| `Arc::clone(&arc)` | 增加强引用计数，返回新的 `Arc`（推荐写法） |
| `Arc::strong_count(&arc)` / `weak_count(&arc)` | 查看当前引用计数，常用于调试 |
| `Arc::get_mut(&mut arc)` | 当且仅当强引用计数为 1 时，获取 `&mut T` |
| `Arc::make_mut(&mut arc)` | 写时复制（Copy-On-Write）：计数为 1 则就地修改，否则克隆一份新数据 |
| `Arc::try_unwrap(arc)` | 尝试取出内部值：计数为 1 返回 `Ok(T)`，否则返回 `Err(Arc<T>)` |
| `Arc::into_inner(arc)`（Rust 1.70+） | 唯一所有者时取出原始值，否则返回 `Err(Arc<T>)` |
| `Arc::new_cyclic` | 优雅构造自引用结构，闭包中接收 `Weak<T>` |
| `Arc::downgrade(&arc)` | 创建 `Weak<T>` 弱引用 |

**关于 unsized 类型**：`Arc` 支持直接包裹 unsized 类型（如 `Arc<[T]>`、`Arc<str>`、`Arc<dyn Trait>`），避免 `Arc<Vec<T>>` 那样的双层间接，节省一层分配和内存开销。

---

## 5. 性能与最佳实践

1. **`Arc::clone` 成本较低**（仅原子加法），但极热路径仍需注意。
2. **单线程场景坚决使用 `Rc`**，只有跨线程时才切换为 `Arc`。
3. **循环引用必须用 `Weak` 解决**，否则会导致内存泄漏。
4. **大块数据共享时**，优先考虑 `Arc<[T]>` 或 `Arc<str>`，避免双层间接。
5. **高性能需求**可搭配 `parking_lot`、`dashmap` 等 crate 替换标准 `Mutex`。
6. **基本类型优先使用原子类型**（如 `AtomicUsize`、`AtomicBool`），避免锁的开销。

**常见应用场景**：
- Web 服务 / 微服务共享配置与缓存
- Tokio 异步任务间状态共享
- 游戏引擎、GUI 资源共享
- 并发数据结构底层实现

---

## 6. 注意事项

### 6.1 线程安全约束

- `Arc<T>` 要求 `T: Send + Sync`，否则无法跨线程使用
- 编译器会在编译期强制检查，大多数违反情况会直接报错

> `Arc<T>` 是 `Send / Sync` $\iff$ `T: Send + Sync`
> **对比 `Box<T>`**：`Box` 只要 `T: Send` 即可。但 `Arc` 是为了共享，必须保证多个线程同时访问 `T` 时也是安全的。

### 6.2 锁中毒（Lock Poisoning）

当持有 `Mutex` / `RwLock` 锁的线程 panic 后，锁会进入"中毒"状态，后续 `lock()` / `write()` 调用会返回 `Err(PoisonError)`。

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

fn main() {
    let lock = Arc::new(Mutex::new(0));
    let l1 = Arc::clone(&lock);

    // 这个线程会 panic，导致锁中毒
    let handle = thread::spawn(move || {
        let _guard = l1.lock().unwrap();
        panic!("意外崩溃！");
    });

    // join 会传播 panic
    let _ = handle.join();

    // 锁已中毒，lock() 返回 Err
    match lock.lock() {
        Ok(guard) => println!("值: {}", *guard),
        Err(poisoned) => {
            // 可以选择恢复：获取内部数据继续使用
            println!("锁已中毒，恢复数据: {}", *poisoned.into_inner());
        }
    }
}
```

> **建议**：示例代码中使用 `.unwrap()` 是为了简洁，生产环境中应根据业务需求决定是 panic、恢复还是忽略中毒状态。

### 6.3 async 场景下的锁选择

在 async 代码中，**跨 `.await` 持有 `std::sync::Mutex` 的锁**会阻塞当前线程，进而可能阻塞整个 async executor（如 Tokio 的多线程运行时）。

```rust
use std::sync::{Arc, Mutex};
use tokio::time::{sleep, Duration};

async fn bad_example(data: Arc<Mutex<Vec<String>>>) {
    let mut guard = data.lock().unwrap(); // 获取 std::sync::Mutex 锁
    sleep(Duration::from_secs(1)).await;   // ⚠️ 跨 .await 持有锁，阻塞线程！
    guard.push("hello".to_string());
}
```

**解决方案**：
- 短临界区：在 `.await` 之前 drop 锁（使用作用域限制 guard 生命周期）
- 长临界区：使用 `tokio::sync::Mutex`（异步锁，不会阻塞线程）

```rust
use tokio::sync::Mutex; // 注意：tokio 的 Mutex

async fn good_example(data: Arc<Mutex<Vec<String>>>) {
    let mut guard = data.lock().await; // 异步等待，不阻塞线程
    sleep(Duration::from_secs(1)).await; // ✅ 安全
    guard.push("hello".to_string());
}
```

> 异步锁是为了保证系统的响应性（不要让某个 Task 饿死），而标准库锁是为了榨干单次操作的执行效率。

### 6.4 内存序（Memory Ordering）

`Arc` 内部通过精密的内存屏障保证了即便计数是原子的，数据的销毁也是线程安全的，用户无需担心可见性问题。，这意味着：

- **仅保证引用计数自身的原子性**（不会出现计数错乱）
- **不保证数据访问的顺序性**（即不作为内存屏障）

这对大多数场景是正确且高效的，因为 `Arc` 的使用者通常会通过锁（`Mutex`/`RwLock`）或其他同步原语来保证数据访问的顺序。但如果你在无锁场景下直接通过 `Arc` 共享数据，需要额外注意同步问题。

### 6.5 循环引用

如 3.3 节所述，双向树、有环图等结构必须使用 `Weak` 打破循环引用。可用 `Arc::strong_count` 和 `Arc::weak_count` 辅助调试。

---

## 7. 速查表：`Arc` 常见组合

|**组合方式**|**内存布局**|**线程安全约束**|**核心适用场景**|**专家点评**|
|:-:|:-:|:-:|:-:|:-:|
|**`Arc<T>`**|1层堆分配|`T: Send + Sync`|共享只读配置、静态资源|性能天花板，除原子计数外零开销。|
|**`Arc<Mutex<T>>`**|1层堆分配|`T: Send`|通用共享可变状态|最稳的选择。若持锁时间极短，性能极佳。|
|**`Arc<RwLock<T>>`**|1层堆分配|`T: Send + Sync`|高频读取、低频写入的缓存|读者不互斥。注意：写者可能被读者“饿死”。|
|**`Arc<AtomicX>`**|1层堆分配|N/A (内置)|计数器、全局状态位、无锁逻辑|**性能巅峰**。利用 CPU 指令同步，无上下文切换。|
|**`Arc<LazyLock<T>>`**|1层堆分配|`T: Send + Sync`|数据库连接池、全局单例|Rust 1.80+ 官方推荐。取代 `lazy_static`。|
|**`Arc<dyn Trait>`**|**2个指针** (数据+虚表)|`Trait: Send + Sync`|插件系统、依赖注入、动态策略|灵活但存在虚函数调用开销，无法内联优化。|
|**`Arc<[T]>`**|**紧凑内存**|`T: Send + Sync`|共享大型只读数组/缓冲区|**推荐**。比 `Arc<Vec<T>>` 少一层内存跳转。|
|**`Arc<UnsafeCell<T>>`**|1层堆分配|**危险**|高性能并发数据结构底层|仅限专家。需手动维护 `Sync` 语义，极易导致 UB。|

---

**一句话总结**：
`Rc` 是单线程共享所有权，`Arc` 是多线程共享所有权。熟练掌握 **`Arc + Mutex/RwLock + Weak`** 这三件套，再配合 `OnceLock`/`LazyLock` 和 async 场景下的锁选择，你就掌握了 Rust 并发共享数据的核心技巧。


Arc 是 Rust 中用于线程安全共享所有权的核心智能指针，全称 Atomically Reference Counted（原子引用计数）。在多线程编程中，当你需要在多个线程之间安全共享同一份数据时，Arc 是最常用、最可靠的工具。

Rust 多线程共享数据利器：深入浅出 `Arc`（原子引用计数）

编程语言

后端

算法

Arc是Rust中实现线程安全共享所有权的智能指针，通过原子引用计数实现多线程数据共享。本文全面解析Arc的基础用法、高级技巧及性能优化，涵盖Arc+Mutex组合、Weak引用、循环引用处理等核心知识点，帮助开发者掌握Rust并发编程的关键技术。

数据库连接池

游戏引擎

数据结构

数据库

大数据

编译器

2026采购季 | AI焕新·智启新局

tencentdb-catalog

bigdata-class

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

Rust 多线程共享数据利器：深入浅出 `Arc`（原子引用计数）-腾讯云开发者社区-腾讯云

Rust 多线程共享数据利器：深入浅出 `Arc`（原子引用计数）

Rust 多线程共享数据利器：深入浅出 `Arc`（原子引用计数）

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐