智能指针

在 Rust 中，智能指针是一类具备指针全部特性的同时，还内置资源管理和自动行为的高级类型。与普通裸指针不同，智能指针允许用户便捷、安全地管理堆上数据、所有权与多线程同步等复杂场景。

Rust 标准库提供了多种常用的智能指针类型，包括：

• Box<T>：实现对堆内存中数据的唯一所有权与自动回收
• Rc<T>：在单线程环境下提供基于引用计数的数据共享
• Arc<T>：在多线程环境下提供原子化的引用计数，实现线程安全的数据共享
• RefCell<T> 和 Cell<T>：在运行时实现内部可变性，支持在不可变引用下修改数据
• Mutex<T> 和 RwLock<T>：提供多线程下的数据互斥与读写锁机制，保证并发安全

这些智能指针分别针对所有权转移、共享访问、运行时可变性和并发同步等需求，帮助开发者解决内存管理、并发安全和所有权控制等系统级编程难题。

Box<T>：把值放到堆上

Box<T> 是最基础的智能指针，它的主要作用是将数据从栈内存移动到堆内存。这样做有几个重要优势：

为什么要用 Box？

• 处理大型数据：当我们有很大的结构体或数组时，直接在栈上分配可能导致栈溢出
• 递归类型：像链表、树这样的递归数据结构在编译期无法确定大小，必须用 Box 包装
• 移动成本低：Box 本身只是一个指针，移动时只需拷贝指针，而不是整个数据
• 所有权清晰：Box 拥有堆上数据的完整所有权，当 Box 被销毁时，堆上的数据也会自动释放

性能特点：

• 分配：在堆上分配内存
• 移动：只移动指针，O(1) 时间复杂度
• 销毁：自动释放堆内存，无需手动管理
• 访问：通过解引用访问数据，性能接近直接访问

|
enum List {
    Cons(i32, Box<List>),
    Nil,
}
 
fn main() {
    let list = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));
    match list { List::Cons(_, _) | List::Nil => println!("ok") }
}

Rc<T>：单线程共享所有权

Rc<T>（Reference Counted）是一个引用计数智能指针，专门为单线程环境设计，让多个变量可以共同拥有同一份数据的所有权。

工作原理：

• 引用计数：Rc 内部维护一个计数器，记录有多少个 Rc 指向同一份数据
• 克隆机制：调用 Rc::clone() 时，只会增加引用计数，不会拷贝底层数据
• 自动释放：当最后一个 Rc 被销毁时，引用计数归零，堆上的数据会自动释放

适用场景：

• 只读共享：多个地方需要读取同一份数据，但不需要修改
• 图结构：节点之间有复杂的引用关系，一个节点可能被多个其他节点引用
• 配合内部可变性：与 RefCell<T> 组合使用，实现共享的可变数据

性能特点：

• 时间：克隆 Rc 是 O(1) 操作，只需增加计数器
• 空间：每个数据只存储一份，多个 Rc 只是共享指针
• 限制：仅限单线程使用，多线程环境需要使用 Arc<T>

|
use std::rc::Rc;
 
fn main() {
    let data = Rc::new(String::from("hello"));
    let a = Rc::clone(&data);
    let b = Rc::clone(&data);
    println!

|
strong_count=3
hello hello hello

Cell<T>/RefCell<T>

在 Rust 的智能指针生态中，Cell<T> 和 RefCell<T> 都属于提供内部可变性的类型，它们允许我们在拥有不可变引用的情况下修改数据，但采用了不同的策略。

Cell<T> 是专门为实现了 Copy trait 的类型设计的，它提供了简单直接的按值读写操作。当我们调用 cell.get() 时，Cell<T> 会返回内部值的一个副本，而 cell.set(value) 则会完全替换内部存储的值。这种设计避免了借用检查的复杂性，因为没有引用被创建，所有操作都是基于值的拷贝。

相比之下，RefCell<T> 采用了更加灵活但也更加复杂的方法。它将 Rust 的借用检查从编译期推迟到运行时进行。当我们使用 borrow() 或 borrow_mut() 方法时，RefCell<T> 会在运行时检查借用规则：同一时刻要么有多个不可变借用，要么有一个可变借用。如果违反了这些规则，程序会直接 panic 而不是编译错误。

RefCell<T> 的核心价值在于它能够在只有不可变引用 &T 的上下文中提供可变借用的能力。这在某些设计模式中非常有用，比如当我们需要在不可变的结构体中修改某个字段，或者在递归数据结构中需要修改节点数据时。通过 RefCell<T>，我们可以绕过编译期的借用检查，在运行时获得修改数据的能力。

|
use std::cell::{Cell, RefCell};
 
fn main() {
    let c = Cell::new(1);
    c.set(2);
    println!("{}", c.get());
 
    let cell = RefCell::new(

|
2
42

Arc<T> 与 Mutex<T>：跨线程共享与同步

当我们的程序需要在多个线程之间共享数据的所有权时，Arc<T>（Atomically Reference Counted）成为了理想的选择。Arc<T> 可以看作是 Rc<T> 的线程安全版本，它使用原子操作来管理引用计数，确保在并发环境下的安全性。与 Rc<T> 只能在单线程中使用不同，Arc<T> 允许我们将同一份数据的克隆引用安全地传递给不同的线程，每个线程都拥有对该数据的共享所有权。

然而，仅仅拥有共享所有权还不够，在实际应用中我们经常需要修改这些共享的数据。由于 Arc<T> 本身只提供不可变访问，当我们需要在多线程环境中修改共享数据时，就需要结合其他同步原语来实现。这时 Mutex<T>（互斥锁）就发挥了关键作用。通过将数据包装在 Mutex<T> 中，然后再用 Arc<T> 包装整个 Mutex<T>，我们就创建了一个既可以安全共享又可以安全修改的数据结构。Mutex<T> 确保同一时刻只有一个线程能够获得数据的可变访问权限，其他线程必须等待锁被释放后才能访问数据。

除了 Mutex<T> 之外，RwLock<T>（读写锁）也是一个重要的选择。在读多写少的场景中，RwLock<T> 能够提供更好的性能，因为它允许多个线程同时进行读操作，只有在写操作时才需要独占访问。这种设计在数据查询频繁而更新相对较少的应用场景中能够显著提升并发性能。

|
use std::sync::{Arc, Mutex};
use std::thread;
 
fn main() {
    let shared = Arc::new(Mutex::new(0));
    let mut handles = vec![];
    for _ in 0..4

|
4

RwLock<T>：多读单写

在某些应用场景中，我们会遇到对共享数据的读操作远多于写操作的情况，比如配置信息的读取、缓存数据的查询等。对于这类读多写少的场景，使用 Mutex<T> 可能会造成不必要的性能损失， 因为即使是多个线程同时进行读操作（这本身是安全的），Mutex<T> 也会强制它们串行执行，一次只允许一个线程访问数据。

RwLock<T>（读写锁）正是为了解决这个问题而设计的。它允许多个线程同时获得读锁（read lock），实现并行读取， 但在需要写操作时会要求独占访问（write lock）。这种机制显著提升了读密集型应用的并发性能，因为读操作不再需要排队等待，可以真正并行执行。

RwLock<T> 的工作原理遵循以下规则：

• 当没有写锁时，任意数量的线程都可以同时获得读锁
• 当有线程持有读锁时，写锁请求会被阻塞直到所有读锁释放
• 当有线程持有写锁时，所有其他的读锁和写锁请求都会被阻塞
• 同一时刻最多只能有一个线程持有写锁

这种设计在数据库系统、缓存系统、配置管理等场景中特别有用，能够在保证数据一致性的同时最大化读操作的并发性能。

|
use std::sync::{Arc, RwLock};
use std::thread;
 
fn main() {
    let data = Arc::new(RwLock::new(0));
    let readers: Vec<_> = (0..3).map