10.1 Arc on 编程那些事儿

10.1.1 布局

Thu, 06 Aug 2026 17:08:00 +0800

译文 · 基于 The Rustonomicon

布局

原文链接: https://doc.rust-lang.org/nomicon/arc-mutex/arc-layout.html

　　先为 Arc 实现确定布局。

　　Arc<T> 提供类型 T 值的线程安全共享所有权，分配在堆上。共享在 Rust 中意味着不可变，因此我们不必设计管理该值访问的机制，对吧？虽然 Mutex 等内部可变性类型允许 Arc 用户创造共享可变性，Arc 本身不必操心这些。

10.1.2 基础代码

Thu, 06 Aug 2026 17:08:00 +0800

译文 · 基于 The Rustonomicon

基础代码

原文链接: https://doc.rust-lang.org/nomicon/arc-mutex/arc-base.html

　　布局已定，来写 Arc 的基础代码。

构造 Arc

　　首先要有构造 Arc<T> 的方式。

　　这很简单：把 ArcInner<T> box 起来，得到指向它的 NonNull<T> 指针。

impl<T> Arc<T> {
 pub fn new(data: T) -> Arc<T> {
 // 引用计数从 1 开始，因为第一个引用就是当前指针。
 let boxed = Box::new(ArcInner {
 rc: AtomicUsize::new(1),
 data,
 });
 Arc {
 // 这里调用 `.unwrap()` 没问题，因为 `Box::into_raw`
 // 返回的指针保证非 null。
 ptr: NonNull::new(Box::into_raw(boxed)).unwrap(),
 phantom: PhantomData,
 }
 }
}

Send 与 Sync

　　我们在做并发原语，需要能跨线程发送。因此可实现 Send 与 Sync 标记 trait。更多信息见 Send 与 Sync 一节。

10.1.3 克隆

Thu, 06 Aug 2026 17:08:00 +0800

译文 · 基于 The Rustonomicon

克隆

原文链接: https://doc.rust-lang.org/nomicon/arc-mutex/arc-clone.html

　　基础代码有了，接下来要能 clone Arc。

　　基本上需要：

递增原子引用计数
用内部指针构造新的 Arc 实例

　　首先访问 ArcInner：

let inner = unsafe { self.ptr.as_ref() };

　　更新原子引用计数：

10.1.4 丢弃

Thu, 06 Aug 2026 17:08:00 +0800

译文 · 基于 The Rustonomicon

丢弃

原文链接: https://doc.rust-lang.org/nomicon/arc-mutex/arc-drop.html

　　现在需要递减引用计数，并在足够低时 drop 数据，否则数据会永远留在堆上。

　　为此实现 Drop。

　　基本上需要：

递减引用计数
若数据只剩一个引用，则：
用原子 fence 防止数据使用与删除的重排序
drop 内部数据

　　首先访问 ArcInner：

10.1.5 最终代码

Thu, 06 Aug 2026 17:08:00 +0800

译文 · 基于 The Rustonomicon

最终代码

原文链接: https://doc.rust-lang.org/nomicon/arc-mutex/arc-final.html

　　最终代码，附一些注释并调整了 import 顺序：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74


use std::marker::PhantomData;
use std::ops::Deref;
use std::ptr::NonNull;
use std::sync::atomic::{self, AtomicUsize, Ordering};

pub struct Arc<T> {
 ptr: NonNull<ArcInner<T>>,
 phantom: PhantomData<ArcInner<T>>,
}

pub struct ArcInner<T> {
 rc: AtomicUsize,
 data: T,
}

impl<T> Arc<T> {
 pub fn new(data: T) -> Arc<T> {
 // 引用计数从 1 开始，因为第一个引用就是当前指针。
 let boxed = Box::new(ArcInner {
 rc: AtomicUsize::new(1),
 data,
 });
 Arc {
 // 这里调用 `.unwrap()` 没问题，因为 `Box::into_raw`
 // 返回的指针保证非 null。
 ptr: NonNull::new(Box::into_raw(boxed)).unwrap(),
 phantom: PhantomData,
 }
 }
}

unsafe impl<T: Sync + Send> Send for Arc<T> {}
unsafe impl<T: Sync + Send> Sync for Arc<T> {}

impl<T> Deref for Arc<T> {
 type Target = T;

 fn deref(&self) -> &T {
 let inner = unsafe { self.ptr.as_ref() };
 &inner.data
 }
}

impl<T> Clone for Arc<T> {
 fn clone(&self) -> Arc<T> {
 let inner = unsafe { self.ptr.as_ref() };
 // 这里用 relaxed ordering 没问题，因为我们不需要任何原子
 // 同步——不修改也不访问内部数据。
 let old_rc = inner.rc.fetch_add(1, Ordering::Relaxed);

 if old_rc >= isize::MAX as usize {
 std::process::abort();
 }

 Self {
 ptr: self.ptr,
 phantom: PhantomData,
 }
 }
}

impl<T> Drop for Arc<T> {
 fn drop(&mut self) {
 let inner = unsafe { self.ptr.as_ref() };
 if inner.rc.fetch_sub(1, Ordering::Release) != 1 {
 return;
 }
 // 这个 fence 用于防止数据使用与删除的重排序。
 atomic::fence(Ordering::Acquire);
 // 这是安全的，因为我们知道持有 `ArcInner` 的最后一个指针，
 // 且指针有效。
 unsafe { Box::from_raw(self.ptr.as_ptr()); }
 }
}