Rc与Arc实现1vN所有权机制

Rust所有权机制要求一个值只能有一个所有者，在大多数情况下，都没有问题，但是考虑以下情况：

• 在图数据结构中，多个边可能会拥有同一个节点，该节点直到没有边指向它时，才应该被释放清理
• 在多线程中，多个线程可能会持有同一个数据，但是你受限于 Rust 的安全机制，无法同时获取该数据的可变引用

为了解决这种问题，Rust通过引用计数的方式，允许一个数据资源在同一时刻拥有多个所有者。这种实现机制就是Rc和Arc，前者适用于单线程，后者适用于多线程。二者大部分情况下都相同。

fn main() {
    let s = String::from("hello, world");
    // s在这里被转移给a
    let a = Box::new(s);
    // 报错！此处继续尝试将 s 转移给 b
    let b = Box::new(s);
}

采用Rc就能解决

use std::rc::Rc;
fn main() {
    let a = Rc::new(String::from("hello, world"));
    let b = Rc::clone(&a);

    assert_eq!(2, Rc::strong_count(&a));
    assert_eq!(Rc::strong_count(&a), Rc::strong_count(&b))
}

使用 Rc::new 创建了一个新的 Rc< String > 智能指针并赋给变量 a，该指针指向底层的字符串数据。智能指针 Rc< T > 在创建时，还会将引用计数加 1，此时获取引用计数的关联函数 Rc::strong_count 返回的值将是 1。

接着，我们又使用 Rc::clone 克隆了一份智能指针 Rc< String >，并将该智能指针的引用计数增加到 2。由于 a 和 b 是同一个智能指针的两个副本，因此通过它们两个获取引用计数的结果都是 2。这里的clone是浅拷贝，仅仅复制了只能指针并增加了引用计数，没有克隆底层数据。

观察引用计数的变化

use std::rc::Rc;
fn main() {
        let a = Rc::new(String::from("test ref counting"));
        println!("count after creating a = {}", Rc::strong_count(&a));
        let b =  Rc::clone(&a);
        println!("count after creating b = {}", Rc::strong_count(&a));
        {
            let c =  Rc::clone(&a);
            println!("count after creating c = {}", Rc::strong_count(&c));
        }
        println!("count after c goes out of scope = {}", Rc::strong_count(&a));


count after creating a = 1
count after creating b = 2
count after creating c = 3
count after c goes out of scope = 2
}

有几点值得注意：

• 由于变量 c 在语句块内部声明，当离开语句块时它会因为超出作用域而被释放，所以引用计数会减少 1，事实上这个得益于 Rc 实现了 Drop 特征
• a、b、c 三个智能指针引用计数都是同样的，并且共享底层的数据，因此打印计数时用哪个都行
• 无法看到的是：当 a、b 超出作用域后，引用计数会变成 0，最终智能指针和它指向的底层字符串都会被清理释放

事实上，RC< T >是指向底层数据的不可变引用，因此你无法通过它来修改数据，因为Rust的借用规则：要么存在多个不可变借用，要么只存在一个可变借用。

一个例子

use std::rc::Rc;

struct Owner {
   name: String,
   // ...其它字段
}

struct Gadget {
   id: i32,
   owner: Rc<Owner>,
   // ...其它字段
}

fn main() {
   // 创建一个基于引用计数的 `Owner`.
   let gadget_owner: Rc<Owner> = Rc::new(Owner {
       name: "Gadget Man".to_string(),
   });

   // 创建两个不同的工具，它们属于同一个主人
   let gadget1 = Gadget {
       id: 1,
       owner: Rc::clone(&gadget_owner),
   };
   let gadget2 = Gadget {
       id: 2,
       owner: Rc::clone(&gadget_owner),
   };

   // 释放掉第一个 `Rc`
   drop(gadget_owner);

   // 尽管在上面我们释放了 gadget_owner，但是依然可以在这里使用 owner 的信息
   // 原因是在 drop 之前，存在三个指向 Gadget Man 的智能指针引用，上面仅仅
   // drop 掉其中一个智能指针引用，而不是 drop 掉 owner 数据，外面还有两个
   // 引用指向底层的 owner 数据，引用计数尚未清零
   // 因此 owner 数据依然可以被使用
   println!("Gadget {} owned by {}", gadget1.id, gadget1.owner.name);
   println!("Gadget {} owned by {}", gadget2.id, gadget2.owner.name);

   // 在函数最后，`gadget1` 和 `gadget2` 也被释放，最终引用计数归零，随后底层
   // 数据也被清理释放
}

Rc简单总结

• Rc/Arc 是不可变引用，你无法修改它指向的值，只能进行读取，如果要修改，需要配合后面章节的内部可变性 RefCell 或互斥锁 Mutex
• 一旦最后一个拥有者消失，则资源会自动被回收，这个生命周期是在编译期就确定下来的
• Rc 只能用于同一线程内部，想要用于线程之间的对象共享，你需要使用 Arc
• Rc< T > 是一个智能指针，实现了 Deref 特征，因此你无需先解开 Rc 指针，再使用里面的 T，而是可以直接使用 T，例如上例中的 gadget1.owner.name

多线程无力的Rc< T >

use std::rc::Rc;
use std::thread;

fn main() {
    let s = Rc::new(String::from("多线程漫游者"));
    for _ in 0..10 {
        let s = Rc::clone(&s);
        let handle = thread::spawn(move || {
           println!("{}", s)
        });
    }
}


error[E0277]: `Rc<String>` cannot be sent between threads safely

表面原因是 Rc< T > 不能在线程间安全的传递，实际上是因为它没有实现 Send 特征，而该特征是恰恰是多线程间传递数据的关键，我们会在多线程章节中进行讲解。

当然，还有更深层的原因：由于 Rc< T > 需要管理引用计数，但是该计数器并没有使用任何并发原语，因此无法实现原子化的计数操作，最终会导致计数错误。

好在天无绝人之路， Rust 为我们提供的功能类似但是多线程安全的 Arc。

Arc

Arc 是 Atomic Rc 的缩写，顾名思义：原子化的 Rc 智能指针。原子化是一种并发原语，我们在后续章节会进行深入讲解，这里你只要知道它能保证我们的数据能够安全的在线程间共享即可。

为何不直接使用 Arc，还要画蛇添足弄一个 Rc，还有 Rust 的基本数据类型、标准库数据类型为什么不自动实现原子化操作？这样就不存在线程不安全的问题了。

原因在于原子化或者其它锁虽然可以带来的线程安全，但是都会伴随着性能损耗，而且这种性能损耗还不小。因此 Rust 把这种选择权交给你，毕竟需要线程安全的代码其实占比并不高，大部分时候我们开发的程序都在一个线程内。
Arc 和 Rc 拥有完全一样的 API，修改起来很简单：

use std::sync::Arc;
use std::thread;

fn main() {
    let s = Arc::new(String::from("多线程漫游者"));
    for _ in 0..10 {
        let s = Arc::clone(&s);
        let handle = thread::spawn(move || {
           println!("{}", s)
        });
    }
}

Arc 和 Rc 并没有定义在同一个模块，前者通过 use std::sync::Arc 来引入，后者通过 use std::rc::Rc

这两者都是只读的，如果想要实现内部数据可修改，必须配合内部可变性 RefCell 或者互斥锁 Mutex 来一起使用。