Rust权威指南之智能指针

原创

Lucky麒麟 2022-12-19 13:49:36 博主文章分类：Rust编程基础 ©著作权

文章标签 智能指针弱引用强引用读书笔记 Rust 文章分类 虚拟化云计算

©著作权归作者所有：来自51CTO博客作者Lucky麒麟的原创作品，请联系作者获取转载授权，否则将追究法律责任

一. 简述

Rust中最常用的指针就是我们在第四章学习过的引用过。引用使用&符号表示的，会借用它所指向的值。智能指针则是一些数据结构，它们的行为类似于指针但拥有额外的元数据和附加功能。智能指针不是Rust所独有的。Rust标准库中不同的人智能指针提供了比引用更为强大的功能。

二. Box

Box是最为简单直接的一种智能指针，它的类型被写作Box<T>。Box使我们可以将数据存储在堆上，并在栈中保留一个指向堆数据的指针。

Box除了将它们的数据存储在堆上而不是栈上，Box没有任何其他的性能开销。

2.1. 使用场景

Box常常被用于下面的场景中：

当我们拥有一个无法在编译时确定大小的类型，但是又想在一个要求固定尺寸的上下文环境中使用这个类型的值时；
当我们需要传递大量数据的所有权，但是又不希望产生大量数据的复制行为时；
当我们希望拥有一个实现了指定trait的类型值，但又不关心具体的类型时；

2.2. 存储数据

我们先看一下Box如何在堆上存储数据，下面的例子中定义了一个持有Box的值的变量data，它指向了堆上的值5。

let data= Box::new(5);
println!("box => {}", data); // box => 5

Box和其他任何拥有所有权的值一样，Box会在离开自己的作用域时被释放。Box被释放的东西除了有存储在栈上的指针，还有它指向的堆数据。

2.3. 存储递归数据

Rust必须在编译时知道每一种类型占据的空间大小，但有一种被称作递归的类型却无法在编译时确定大小。如下：

enum List {
    Cons(i32, List),
    Nil,
}

此时编译器会报如下错误：recursive type List has infinite size。如果你有其他的语言的编程基础的话，这就是一种比较常见的递归结构。但是由于Rust在编译时需要知道一种类型占据空间的大小，但是此时递归结构就无法确定类型的大小了。此时我们就可以通过Box修复这个问题，因为Box是大小可确定的。

#[derive(Debug)]
enum List {
    Cons(i32, Box<List>),
    Nil,
}
#[test]
fn box_cons() {
    let list = Cons(1,
        Box::new(Cons(2,
            Box::new(Cons(3,
                Box::new(Nil)
            ))
        ))
    );
    println!("{:?}", list); // Cons(1, Cons(2, Cons(3, Nil)))
}

三. Deref和Drop

上面的Box属于智能指针，是因为它实现了Deref，并允许我们将Box的值当作引用来对待。当一个Box值离开作用域时，因为它实现了Drop，所以Box指向堆数据会自动的被清理释放掉。

3.1. Deref将智能指针视作常规引用

实现Deref使我们可以自定义解引用运算符*的行为（这一符号也也同时被用作乘法运算符和通配符）。通过实现Deref，我们可以将智能指针视作常规引用来进行处理。

常规引用就是一种类型的指针。我们可以理解为一个箭头，它会指向存储在别处的某个值，下面看一个通过解引用运算符跟踪数据的值：

#[test]
fn deref_test() {
    let x = 5; // 变量x存储了i32的值5
    let y = &x; // 变量y中存储了x的引用
    assert_eq!(5, x);
    assert_eq!(5, *y); // 这里*y来跟踪引用并跳转到它指向的值（也就是解引用）
    assert_eq!(5, y); // ERROR 由于数值和引用是两种不同的类型
}

接着我们看一下Box的解引用，此时解引用运算符能够正常工作。

#[test]
fn deref_box_test() {
    let x = 5;
    let y = Box::new(x); // 变量y设置为了一个指向x值的装箱指针，而不是一个指向x值的引用
    assert_eq!(5, x);
    assert_eq!(5, *y); // 此处我们就可以使用解引用运算符来跟踪装箱指针，正如我们跟踪引用一样
}

此时解引用运算符可以使用是因为Box实现了Deref，标准库中的Deref要求我们现实一个deref方法，该方法会借用self并返回一个指向内部数据的引用。在没有Deref的情形下，编译器只能对&形式的常规引用执行解引用操作。deref方法使编译器可以从任何实现了Deref的类型中获取值，并能够调用deref方法来获取一个可以进行解引用操作的引用。上面例子中的*y会被Rust隐式地展开为：

*(y.deref())

Rust使用*运算符来替代deref方法和另一个朴素的解引用操作，这样我们就不用考虑是否需要调用deref方法了。

3.1.1. 自定义智能指针

下面我们实现一个自己的智能指针，实现deref方法，该方法会借用self并返回一个指向内部数据的引用。

struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
} 

impl<T> Deref for MyBox<T> {
    type Target = T; // 关联类型
    fn deref(&self) -> &T {
        &self.0 // 在deref的方法体中填入&self.0，这意味着deref会返回一个指向值的引用，进而允许调用者通过*运算符访问值
    }
}

3.1.2. 函数和方法的隐式解引用转换

解引用转换是Rust为函数和方法的参数提供了一个种便携特性。当某个类型T实现了Deref，它能够将T的引用转换为T经过Deref操作后生成的引用。当我们将某个特定类型的值引用作为参数传递给函数或方法，但是传入的类型与参数类型不一致时，解引用转换就会自动发生。例子：

fn hello(name: &str) {
    println!("Hello, {}", name);
}

#[test]
fn test_hello() {
    let m = MyBox::new(String::from("Rust"));
    hello(&m); //  @1  Hello, Rust
    // hello(&(*m)[..]));  @2  没有解引用就需要这样写了
}

借助于解引用转换特性，我们这里可以将字符串切片作为参数传入hello函数，也可以将MyBox<String>值的引用传入hello函数。将参数&m传入hello函数，而&m正是一个指向MyBox<String>值的引用。因为MyBox实现了Deref，所有Rust可以通过deref来将&MyBox<String>转换为&String，标准库为String提供的Deref实现会返回字符串切片，所以Rust可以继续调用deref来将&String转换为&str，并最终与hello函数的定义相匹配。

如果Rust没有实现解引用转换功能，必须编写@1这样，首先*m将MyBox进行解引用得到String，然后通过&和[..]来获取包含整个String的字符串切片以匹配hello函数签名。整个过程代码编写非常不友好。

3.1.3. 解引用转换和可变性

使用Deref能够重载不可变引用的*运算符。与之类似，使用DerefMut能够重载可变引用的*运算符。Rust会在类型与trait满足一下三种情形时执行解引用转换：

当T: Deref<Target=U>时，允许&T转换为&U；
当T: DerefMut<Target=U>时，允许&mut T转换为&mut U；
当T: Deref<Target=U>时，允许将&mut T转化为&U；

前两种情形除可变性之外是完全相同的。其中，情形一意味着，如果T实现了类型U的Deref，那么&T就可以直接转换为&U。情形二意味着，同样的解引用转换过程会作用于可变引用。

情形三则意味着，Rust会将一个可变引用自动转换为一个不可变的引用。但是这个过程中不可变引用永远不可能转换为可变引用。

3.2. Drop清理运行时代码

下面我们在介绍一个对于智能指针十分重要的trait就是Drop，它允许我们在变量离开作用域的时候执行某些自定义操作。我们可以为任意类型实现一个Drop，它常常被用来释放诸如文件、网络连接等资源。几乎每一种智能指针都会用到Drop。下面我们看一个例子：

struct CustomSmartPointer {
    data: String,
}

impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("Dropping CustomSmartPointer with data: {}", self.data);
    }
}

#[test]
fn drop_test() {
    let a = CustomSmartPointer { data: String::from("hello") };
    let c = CustomSmartPointer { data: String::from("world") };
    println!("CustomSmartPointer Created");
}

当我们类型实例离开作用域时运行的逻辑都可以放在drop函数体内，Rust会自动调用我们在drop方法中放置的代码来打印出最终的信息，而无需显示地调用drop方法。编译执行输出：

CustomSmartPointer Created
Dropping CustomSmartPointer with data: world
Dropping CustomSmartPointer with data: hello

Rust在实例离开作用域时自动调用了我们编写的drop代码。因为变量的丢弃顺序与创建顺序相反，所有c在a之前被丢弃。

在Rust中我们是无法直接禁用自动drop功能，因为Drop存在就是为了完成自动释放的逻辑。但是我们倒是常常会碰到需要提前清理一个值的情形，例如使用智能指针来管理锁时，我们就需要强制运行drop方法来提前释放锁。此时我们就可以调用标准库中std::mem::drop函数来提前清理某个值。例子：

注意：我们是不能手动显示的调用Drop的drop方法。

#[test]
fn drop_test() {
    let a = CustomSmartPointer { data: String::from("hello world") };
    println!("CustomSmartPointer Created");
    drop(a);
    println!("CustomSmartPointer Drop after");
}

编译执行输出如下：说明在值离开作用域调用std::mem::drop来显式地丢弃它。

CustomSmartPointer Created
Dropping CustomSmartPointer with data: hello world // 调用的Drop的drop的方法
CustomSmartPointer Drop after

四. Rc/RefCell/Weak

4.1. 基于引用计数的智能指针Rc<T>

Rust提供了一个名为Rc<T>的类型来支持多重所有权，它名称中的Rc的缩写。Rc<T>类型的实例会在内部维护一个用于记录值引用次数的计数器，从而确认这个值是否仍在使用。如果对一个值的引用次数为零，那么就可以意味着这个值可以安全地清理掉，而不会触发引用失效的问题。

当你希望将堆上的一些数据分享给程序的多个部分同时使用，而无法在编译期确定哪个部分会最后释放这些数据时，我们就可以使用Rc<T>类型。相反地，如果我们能够在编译期确定那一部分会最后释放数据，那么就只需要让这部分代码称为数据的所有者即可，仅仅靠编译期的所有权规则也可以保证程序的正确性。例子：

注意： Rc<T>只能被用于单线程场景中。

use std::rc::Rc;

#[derive(Debug)]
enum List {
    Cons(i32, Rc<List>),
    Nil,
}

#[cfg(test)]
mod tests {
    use std::rc::Rc;
    use crate::List::{Cons, Nil};
    use super::*;

    #[test]
    fn link_test() {
        let a = Rc::new(
            Cons(5,
                 Rc::new(
                     Cons(10,
                          Rc::new(Nil)
                     )
                 )
            )
        );
        println!("count after creating a = {}", Rc::strong_count(&a));
        let b = Cons(3, Rc::clone(&a));
        println!("count after creating b = {}", Rc::strong_count(&a));
        {
            let c = Cons(4, Rc::clone(&a));
            println!("count after creating c = {}", Rc::strong_count(&a));
        }
        println!("count after c goes out of scope = {}", Rc::strong_count(&a));
    }
}

由于Rc<T>没有包含在预导入模块中，需要我们使用use语句将它引入作用域。上面例子调用Rc::clone不会执行数据的深拷贝操作，只会增加引用计数，并且这不会花费太多时间。深拷贝则常常需要花费大量时间来搬用数据。并且我们可以使用Rc::strong_count方法获取引用计数。上面例子输出结果：

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<T>的Drop实现会在Rc<T>离开作用域时自动将引用计数减1。

4.2. RefCell<T>和内部可变性模式

内部可变性是Rust的设计模式之一，它允许你在只持有不可变引用的前提下对数据进行修改；通常情况下，类似的行为会被借用规则所禁止。内部可变性模式在它的数据结构中使用了unsafe代码来绕过Rust正常的可变性和借用规则。

在Rust的借用规则是这样的：在任何给定的时间里，要么只能拥有一个可变引用，要么只能拥有任意数量的不可变引用；引用总是有效的。对于一般引用和Box<T>的代码，Rust会在编译阶段强制代码准守这些借用规则。但是对于RefCell<T>的代码，Rust则只会在运行时检查这些规则，并在出现违反借用规则的情况下触发panic来提前终止程序。

将借用规则的检查放在编译期有许多优势：它不仅可以帮助我们在开发阶段尽早的暴露问题，而且不会带来任何运行时开销。

RefCell<T>也只能使用在单线程场景中。强行将它运用于多线程场景会产生编译错误。下面列举上一些Box、Rc或者RefCell选择依据：

Rc<T>允许一份数据有多个所有者，而Box<T>和RefCell<T>都只有一个所有者；
Box<T>允许在编译时检查的可变或不可变借用，Rc<T>仅允许编译时检查不可变借用，RefCell<T>允许运行时检查的可变和不可变借用；
由于RefCell<T>允许我们在运行时检查可变借用，所以即便RefCell<T>本身是不可变的，我们仍然能够改变其中存储的值

4.2.1. RefCell修改不可变值

下面我们使用RefCell<T>修改不可变值的例子：

// 定义一个约束，其中有一个方法是send
trait Messenger {
    fn send(&self, msg: &str);
}
// 结构体属性包含对应Messenger约束的实现类型引用
struct LimitTracker<'a, T: 'a + Messenger> {
    messenger: &'a T,
    value: usize,
    max: usize,
}

impl<'a, T> LimitTracker<'a, T> where T: Messenger {
    fn new(messenger: &T, max: usize) -> LimitTracker<T> {
        LimitTracker {
            messenger,
            value: 0,
            max
        }
    }

    fn set_value(&mut self, value: usize) {
        self.value = value;
        let percentage_of_max = self.value as f64 / self.max as f64;
        // 条件判断send不同的值
        if percentage_of_max >= 1.0 {
            self.messenger.send("Error: You are over your quota!");
        } else if percentage_of_max >= 0.9 {
            self.messenger.send("Urgent Warning: You've used up over 90% of your quota!");
        } else if percentage_of_max >= 0.75 {
            self.messenger.send("Warning: You've used up over 75% of your quota!");
        }
    }
}

下面我们在单元测试编写具体的Messenger约束的实现：

#[cfg(test)]
mod tests {
    use super::*;
    
    struct MockMessenger {
        sent_message: Vec<String>,
    }

    impl MockMessenger {
        fn new() -> MockMessenger {
            MockMessenger { sent_message: vec![] }
        }
    }
    // 实现Messenger,在send方法中添加字符串，这里涉及到需要修改sent_messenger
    impl Messenger for MockMessenger {
        fn send(&self, msg: &str) {
            self.sent_message.push(String::from(msg));
        }
    }

    #[test]
    fn send_message() {
        let messenger = MockMessenger::new();
        let mut tracker = LimitTracker::new(&messenger, 100);
        tracker.set_value(80);
        assert_eq!(messenger.sent_message.len(), 1);
    }
}

上面的例子很明显是无法编译通过的，这时因为我们在Messenger的约束中的send方法中的参数是&self，不可变引用；但是我们在send的具体实现中我们却需要一个可变引用去修改Vec中的数据。此时我们就可以使用RefCell<T>进行修改修复这个问题，实现既不用修改约束的定义还可以实现sent_message属性的修改。

#[cfg(test)]
mod tests {
    use super::*;
    
    struct MockMessenger {
        sent_message: RefCell<Vec<String>>, // @1
    }

    impl MockMessenger {
        fn new() -> MockMessenger {
            MockMessenger { sent_message: RefCell::new(vec![]) } // @2
        }
    }
    // 实现Messenger,在send方法中添加字符串，这里涉及到需要修改sent_messenger
    impl Messenger for MockMessenger {
        fn send(&self, msg: &str) {
            self.sent_message.borrow_mut().push(String::from(msg)); // @3
        }
    }

    #[test]
    fn send_message() {
        let messenger = MockMessenger::new();
        let mut tracker = LimitTracker::new(&messenger, 100);
        tracker.set_value(80);
        assert_eq!(messenger.sent_message.borrow().len(), 1); // @4
    }
}

上面代码中我们进行了4处修改，sent_message的类型修改为RefCell<Vec<String>>，在send具体实现中使用borrow_mut方法来获取RefCell<T>内部值的可变引用，此时我们就可以在动态数组中push字符串了。

4.2.2. RefCell详解

Rust中不可变和可变引用分别使用语法&和&mut；对应RefCell<T>而言，我们需要将borrow和borrow_mut方法来实现类似的功能，borrow和borrow_mut两个方法分别返回的是Ref<T>和RefMut<T>两种指针指针，它们都是实现了Deref，所有我们可以将它们当作一般引用来对待。

RefCell<T>会记录当前存在多少个活跃的Ref<T>和RefMut<T>智能指针。每次调用borrow方法，RefCell<T>会将活跃的不可变借用计数加1，并且在任何一个Ref<T>值离开作用域被释放时，不可变借用计数减1。RefCell<T>会基于这一技术来维护和编译器同样的借用检查规则：在任何一个给定的时间里，它只允许你拥有多个不可变借用或一个可变借用。

4.2.3. 实现一个拥有多重所有权的可变数据

将Rc<T>和RefCell<T>结合使用是一种很常见的用法。Rc<T>允许多个所有者持有同一个数据，但是只能提供对数据的不可变访问。如果我们在Rc<T>内存储RefCell<T>，就可以定义处拥有多个所有者且能够对值进行修改。

#[derive(Debug)]
enum List {
    // RefCell可义实现修改列表内数值的功能
    Cons(Rc<RefCell<i32>>, Rc<List>),
    Nil,
}

#[test]
fn link_test() {
    let value = Rc::new(RefCell::new(5));
    let a = Rc::new(
        Cons(
            Rc::clone(&value),
            Rc::new(Nil)
        )
    );
    let b = Rc::new(
        Cons(
            Rc::new(RefCell::new(6)),
            Rc::clone(&a)
        )
    );
    let c = Rc::new(
        Cons(
            Rc::new(RefCell::new(10)),
            Rc::clone(&a)
        )
    );
    // 修改值
    *value.borrow_mut() += 10;
}

在Rust的标准库中还有其他的一些类型来实现内部可变性，例如与RefCell<T>十分类似的Cell<T>，Cell<T>是通过复制来访问数据，还有后续章节中的Mutex<T>，它被用于实现跨线程情形下的内部可变性模式。

4.3. Weak<T>避免循环引用

Rust提供的内存安全保障是我们很难在程序中意外地制造出永远不会得到的释放的内存空间。但是这也不是不可能的。与数据竞争不同，在编译期彻底防止内存泄漏并不是Rust作出的保证之一，这也意味着内存泄漏在Rust中是一种内存安全行为。

4.3.1. 创建循环引用

我们可以通过使用Rc<T>和RefCell<T>看到Rust是允许内存泄漏的，我们能够创建出相互引用成环状的实例，由于环中每一个指针的引用计数都不会减少到0，所以对应的值也不会被释放丢弃，这就造成了内存泄漏。下面我们演示一个循环引用的例子。

我们先定一个枚举，并发实现一个tail方法用以获取元素：

use std::cell::RefCell;
use std::rc::Rc;
use crate::List::{Cons, Nil};

#[derive(Debug)]
enum List {
    Cons(i32, RefCell<Rc<List>>),
    Nil,
}

impl List {
    fn tail(&self) -> Option<&RefCell<Rc<List>>> {
        match self {
            Cons(_, item) => Some(item),
            Nil => None
        }
    }
}

这里的RefCell<Rc<T>>类型，这可以让我们灵活修改Cons变体指向下一个List值。下面看下如何构建一个循环引用的情况（其实很简单，就是相当于环形链表一样）

#[cfg(test)]
mod tests {
    use std::borrow::BorrowMut;
    use super::*;

    #[test]
    fn loop_quote() {
        let a = Rc::new(Cons(5, RefCell::new(Rc::new(Nil))));
        let b = Rc::new(Cons(6, RefCell::new(Rc::clone(&a))));
        let c = Rc::new(Cons(7, RefCell::new(Rc::clone(&b))));
        if let Some(link) = a.tail() {
            *link.borrow_mut() = Rc::clone(&c)
        }
        assert_eq!(2, Rc::strong_count(&a));
        assert_eq!(2, Rc::strong_count(&b));
        assert_eq!(2, Rc::strong_count(&c));
        // println!("{:?}", a.tail()); 这里会因为循环引用发生栈溢出
    }
}

上面的例子我们实现了a、b和c的引用首尾相连的环，当此时因为首尾相连导致引用计数都不会是0，导致内存会永远以引用计数为1的状态保留在堆上。

一般来说解决循环引用的方案需要重新组织数据结构，它会将引用拆分为持有所有权和不持有所有权两种情形。

4.3.2. 使用Weak<T>替换Rc<T>

在上面的学习过程中，我们知道Rc::clone来增加Rc<T>实例的strong_count引用计数，并指出在strong_count为0时才会被清理。此时我们还可以通过Rc::downgrade函数创建出Rc<T>实例中值的弱引用。这个函数会返回一个类型为Weak<T>的智能指针，这一操作会让Rc<T>中的weak_count计数增加1，而不会改变strong_count的状态；并且Rc<T>在执行清理之前不会要求weak_count必须减为0。

强引用可以用来共享Rc<T>实例的所有权，而弱引用则不会表达所有权关系。一旦强引用计数减为0，任何由弱引用组成的循环就会被打破，所有弱引用不会造成循环引用。

注意：由于我们无法确认Weak<T>引用的值是否已经被释放了，所以我们在使用Weak<T>指向的值之前确保它仍然存在。此时我们可以调用Weak<T>实例上的upgrade方法来验证，该函数返回的是一个Option<Rc<T>>。

下面我们看一个创建树状数据结构的例子：

#[derive(Debug)]
struct Node {
    value: i32,
    // 父节点信息，我们这里使用RefCell包裹Weak弱引用，不持有父节点的所有权
    parent: RefCell<Weak<Node>>,
    // 子节点信息，使用RefCell可以修改节点的父子关系
    children: RefCell<Vec<Rc<Node>>>,
}

impl Node {
    fn new(value: i32) -> Self {
        Node {
            value,
            parent: RefCell::new(Weak::new()),
            children: RefCell::new(vec![]),
        }
    }
}

fn quote_info<T>(data: &Rc<T>) {
    println!("node => [strong: {}] : [weak: {}]", Rc::strong_count(data), Rc::weak_count(data));
}

接着我们创建几个节点构建一颗简单的树，并查看它的强弱引用数量：

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn weak_quote() {
        let left = Rc::new(Node::new(3));
        quote_info(&left); // node => [strong: 1] : [weak: 0]
        {
            let branch = Rc::new(Node {
                value: 5,
                parent: RefCell::new(Weak::new()),
                children: RefCell::new(vec![Rc::clone(&left)])
            });
            *left.parent.borrow_mut() = Rc::downgrade(&branch);
            quote_info(&branch); // node => [strong: 1] : [weak: 1]
            quote_info(&left); // node => [strong: 2] : [weak: 0]
        }
        quote_info(&left); // node => [strong: 1] : [weak: 0]
    }
}