剖析智能指针 Rc Weak 与 Arc

我们知道 rust ownership 有三原则:

  • 每个值 value, 都有一个所有者 owner
  • 同一时间,一个值只能有一个所有者 owner
  • 当所有者 owner 离开作用域,对应的值会自动 dropped

但有些时候一个值,要被多个变量共享。同时无法用引用来解决,因为不确定哪个变量最后结束,无法确定生命周期。所以这时候 Rc reference count 智能指针派上用场了, Rc 共享所有权,每增加一个引用时,计数加一,离开作用域时减一,当引用计数为 0 时执行析构函数

Rc 线程不安全,跨线程时需要使用 Arc, 其中 A 是 atomic 原子的意思

查看引用计数

use std::rc::Rc;

fn main() {
    let a = Rc::new(String::from("https://mytechshares.com/"));
    println!("ref count is {}", Rc::strong_count(&a));
    let b = Rc::clone(&a);
    println!("ref count is {}", Rc::strong_count(&a));
    {
        let c = Rc::clone(&a);
        println!("ref count is {}", Rc::strong_count(&a));
        println!("ref count is {}", Rc::strong_count(&c));
    }
    println!("ref count is {}", Rc::strong_count(&a));
}

strong_count 查看引用计数,变量 c 在 inner 词法作用域内,在离开作用域前打印查看引用计数

    Finished dev [unoptimized + debuginfo] target(s) in 0.03s
     Running `target/debug/hello_cargo`
ref count is 1
ref count is 2
ref count is 3
ref count is 3
ref count is 2

每增加一次引用,计数都会加一,在 inner 语句块中,count 是 3,但当离开后,计数减为 2

循环引用

熟悉 Garbage Collection 的都知道,有的 GC 算法就靠的引用计数,比如 python 的实现。比如 Redis object 同样用 rc 来实现,由于 redis rc 并不暴露给用户,只要写代码时注意引用方向,就不会写出循环引用,但是 rust Rc 就无法避免,先来看个例子

use std::rc::Rc;
use std::cell::RefCell;

struct Node {
    next: Option<Rc<RefCell<Node>>>,
}

impl Drop for Node {
    fn drop(&mut self) {
        println!("Dropping https://mytechshares.com 董泽润的技术笔记");
    }
}

fn main() {
    let first = Rc::new(RefCell::new(Node {next: None}));
    let second = Rc::new(RefCell::new(Node {next: None}));
    let third = Rc::new(RefCell::new(Node {next: None}));
    (*first).borrow_mut().next = Some(Rc::clone(&second));
    (*second).borrow_mut().next = Some(Rc::clone(&third));
    (*third).borrow_mut().next = Some(Rc::clone(&first));
}

这是一个环形链表的代表,稍微有点绕,原理就是 first -> second -> third, 同时 third -> first, 代码运行后,并没有打印 Dropping https://mytechshares.com 董泽润的技术笔记

这里面 RefCell, borrow_mut 有点绕,刚学 rust 时一直读不懂,下一篇会详细讲解。简单说就是 RefCell, Cell 提供了一种机制叫 内部可变性,因为 Rc 共享变量所有权,所以要求只能读不允许修改。那么 Rc 里面的值包一层 RefCell, Cell 就可以避开编译器检查,变成运行时检查,相当于开了个后门。Rust 里大量使用这种设计模式

那么如何 fix 这个循环引用呢?答案是 Weak 指针,只增加引用逻辑,不共享所有权,即不增加 strong reference count

use std::rc::Rc;
use std::rc::Weak;
use std::cell::RefCell;

struct Node {
    next: Option<Rc<RefCell<Node>>>,
    head: Option<Weak<RefCell<Node>>>,
}

impl Drop for Node {
    fn drop(&mut self) {
        println!("Dropping https://mytechshares.com 董泽润的技术笔记");
    }
}

fn main() {
    let first = Rc::new(RefCell::new(Node {next: None, head: None}));
    let second = Rc::new(RefCell::new(Node {next: None, head: None}));
    let third = Rc::new(RefCell::new(Node {next: None, head: None}));
    (*first).borrow_mut().next = Some(Rc::clone(&second));
    (*second).borrow_mut().next = Some(Rc::clone(&third));
    (*third).borrow_mut().head = Some(Rc::downgrade(&first));
}

这是修复后的代码,增加一个 head 字段,Weak 类型的指针,通过 Rc::downgrade 来生成 first 的弱引用

# cargo run
   Compiling hello_cargo v0.1.0 (/root/zerun.dong/code/rusttest/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 2.63s
     Running `target/debug/hello_cargo`
Dropping https://mytechshares.com 董泽润的技术笔记
Dropping https://mytechshares.com 董泽润的技术笔记
Dropping https://mytechshares.com 董泽润的技术笔记

运行后看到,打印了三次 Dropping 信息,符合预期。另外由于 Weak 指针指向的对象可能析构了,所以不能直接解引用,要模式匹配,再 upgrade

线程安全 Arc

让我们看一个并发修改变量的例子,来自the rust book 官网

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 counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();

            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("董泽润的技术笔记 Got Result: {}", *counter.lock().unwrap());
}

spawn 开启 10 个线程,并发对 counter 加一,最后运行后打印

# cargo run
   Compiling hello_cargo v0.1.0 (/root/zerun.dong/code/rusttest/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 3.72s
     Running `target/debug/hello_cargo`
董泽润的技术笔记  Got Result: 10

刚学的时候确实很绕,连并发修改变量都这么麻烦,各种 ArcMutex, 其实这都是为了实现零成本的运行时安全,总要有人做 GC 方面的工作

而且各种 wrapper 并不妨碍阅读源码,忽略就好,关注代码逻辑,只有写的时候才需要仔细思考

底层实现

#[stable(feature = "rust1", since = "1.0.0")]
pub struct Rc<T: ?Sized> {
    ptr: NonNull<RcBox<T>>,
    phantom: PhantomData<RcBox<T>>,
}

#[repr(C)]
struct RcBox<T: ?Sized> {
    strong: Cell<usize>,
    weak: Cell<usize>,
    value: T,
}

Rc 是一个结构体,两个字段 ptr, phantom 成员都是 RcBox 类型,注意看里面有 strong, weak 计数字段和真实数据 value 字段,就里再次看到了 Cell 来实现的内部可变量

PhantomData 是幽灵数据类型,参考 nomicon 文档,大致场景就是:

在编写非安全代码时,我们常常遇见这种情况:类型或生命周期逻辑上与一个结构体关联起来了,但是却不属于结构体的任何一个成员。这种情况对于生命周期尤为常见。

PhantomData 不消耗存储空间,它只是模拟了某种类型的数据,以方便静态分析。这么做比显式地告诉类型系统你需要的变性更不容易出错,而且还能提供 drop 检查需要的信息

Zero-sized type used to mark things that "act like" they own a `T`.

Adding a `PhantomData<T>` field to your type tells the compiler that your
type acts as though it stores a value of type `T`, even though it doesn't
really. This information is used when computing certain safety properties.

简单说 PhantomData 就是零长的占位符,告诉编译器看起来我拥有这个 T, 但不属于我,同时如果析构时,也要调用 drop 释放 T. 因为幽灵字段的存在,Rc 是不拥有 RcBox 的,NonNull 告诉编译器,这个指针 ptr 一定不为空,你可以优化,Option<Rc<T>>Rc<T> 占用相同的大小,去掉了是否为空的标记字段

    pub fn new(value: T) -> Rc<T> {
        // There is an implicit weak pointer owned by all the strong
        // pointers, which ensures that the weak destructor never frees
        // the allocation while the strong destructor is running, even
        // if the weak pointer is stored inside the strong one.
        Self::from_inner(
            Box::leak(box RcBox { strong: Cell::new(1), weak: Cell::new(1), value }).into(),
        )
    }

从初始化 Rc::new 代码中看到,初始 strong, weak 计数值均为 1

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?SizedClone for Rc<T> {
    #[inline]
    fn clone(&self) -> Rc<T> {
        self.inner().inc_strong();
        Self::from_inner(self.ptr)
    }
}

impl<T: ?Sized> Rc<T> {
    #[inline(always)]
    fn inner(&self) -> &RcBox<T> {
        // This unsafety is ok because while this Rc is alive we're guaranteed
        // that the inner pointer is valid.
        unsafe { self.ptr.as_ref() }
    }
}

fn inc_strong(&self) {
  let strong = self.strong();

  // We want to abort on overflow instead of dropping the value.
  // The reference count will never be zero when this is called;
  // nevertheless, we insert an abort here to hint LLVM at
  // an otherwise missed optimization.
  if strong == 0 || strong == usize::MAX {
      abort();
  }
  self.strong_ref().set(strong + 1);

Rc::clone 并不会拷贝数据,只增加 strong ref count 强引用计数

#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl<#[may_dangle] T: ?SizedDrop for Rc<T> {

    fn drop(&mut self) {
        unsafe {
            self.inner().dec_strong();
            if self.inner().strong() == 0 {
                // destroy the contained object
                ptr::drop_in_place(Self::get_mut_unchecked(self));

                // remove the implicit "strong weak" pointer now that we've
                // destroyed the contents.
                self.inner().dec_weak();

                if self.inner().weak() == 0 {
                    Global.deallocate(self.ptr.cast(), Layout::for_value(self.ptr.as_ref()));
                }
            }
        }
    }
}

可以看到 drop 时先做计数减一操作,如果 strong ref count 到 0,开始析构释放对象。同时 weak 减一,如果为 0, 就要释放 RcBox, 也就是 RcBoxValue T 是单独释放的

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

struct ArcInner<T: ?Sized> {
    strong: atomic::AtomicUsize,

    // the value usize::MAX acts as a sentinel for temporarily "locking" the
    // ability to upgrade weak pointers or downgrade strong ones; this is used
    // to avoid races in `make_mut` and `get_mut`.
    weak: atomic::AtomicUsize,

    data: T,
}

Arc 里面的计数是用 atomic 来保证原子的,所以是并发字全。

#[stable(feature = "rc_weak", since = "1.4.0")]
pub struct Weak<T: ?Sized> {
    // This is a `NonNull` to allow optimizing the size of this type in enums,
    // but it is not necessarily a valid pointer.
    // `Weak::new` sets this to `usize::MAX` so that it doesn’t need
    // to allocate space on the heap.  That's not a value a real pointer
    // will ever have because RcBox has alignment at least 2.
    // This is only possible when `T: Sized`; unsized `T` never dangle.
    ptr: NonNull<RcBox<T>>,
}

#[stable(feature = "rc_weak", since = "1.4.0")]
pub fn downgrade(this: &Self) -> Weak<T> {
    this.inner().inc_weak();
    // Make sure we do not create a dangling Weak
    debug_assert!(!is_dangling(this.ptr.as_ptr()));
    Weak { ptr: this.ptr }
}s

Rc::downgrade 生成 Weak 逻辑也比较简单,inc_weak 增加 weak ref count 弱引用计数,然后返回 Weak

还有很多源码实现,理解有点难,多 google 查查,再读读注释,感兴趣自行查看

小结

本文先分享这些,写文章不容易,如果对大家有所帮助和启发,请大家帮忙点击在看点赞分享 三连

关于 Rc/Arc 智能指针 大家有什么看法,欢迎留言一起讨论,如果理解有误,请大家指正 ^_^

Click to rate this post!
[Total: 0 Average: 0]

人已赞赏
名家说每日优选

DFINITY|CipherODM — DFINITY上的开放数据市场

2021-8-19 13:37:00

Rust开发小白百科每日优选

【译文】Rust Slice Pattern:切片模式

2021-8-19 13:37:53

0 条回复 A文章作者 M管理员
    暂无讨论,说说你的看法吧
个人中心
购物车
优惠劵
今日签到
有新私信 私信列表
有新消息 消息中心
搜索