Rust学习笔记4：智能指针、引用和并发

Drop特征

使用drop方法可以回收所有权，释放内存。drop方法不需要程序员手动调用，编译器会为我们自动插入drop代码并在变量退出作用域时调用之。调用顺序是：

• 先声明的后调用，后声明的先调用；
• 在结构体内，结构体的drop先调用，继而按照字段的定义顺序调用字段的drop方法。

对于下面这个示例：

// 定义一个简单的结构体
struct Resource {
    name: String,
}

// 为 Resource 实现 Drop trait
impl Drop for Resource {
    fn drop(&mut self) {
        println!("Dropping resource: {}", self.name);
    }
}

fn main() {
    // 创建两个 Resource 实例
    let resource1 = Resource {
        name: "Resource 1".to_string(),
    };
    let resource2 = Resource {
        name: "Resource 2".to_string(),
    };

    // 创建一个作用域
    {
        let resource3 = Resource {
            name: "Resource 3".to_string(),
        };
        println!("Resource 3 is in scope");
    } // resource3 离开作用域，drop 方法被调用

    println!("End of main function");
    // resource1 和 resource2 离开作用域，drop 方法被调用
}

输出顺序为：

Resource 3 is in scope Dropping resource: Resource 3 End of main function Dropping resource: Resource 2 Dropping resource: Resource 1

这个顺序验证了上面所讲的drop次序。

引用计数智能指针Rc与Arc

Rc是reference counting的缩写，是引用计数的意思，当我们使用它时，Rust会自动统计、管理引用记数，并在记数为0的时候自动将对象回收。我们可以通用Rc::clone复制对象——复制的仅仅是引用，同时让引用记数加1；可以通过Rc::string_count随时查看引用计数。

无论是Rc还是Arc，都是不可变记数引用，都不能对数据进行修改。两者在使用上没有区别，唯一的区别在于前者用于单线程内，后者用于多线程内。下面看一个Rc的示例：

use std::rc::Rc;

fn main() {
    // 创建一个 Rc 实例，引用计数为 1
    let data = Rc::new(42);

    // 克隆 Rc，引用计数增加
    let _data_clone1 = Rc::clone(&data);
    let _data_clone2 = Rc::clone(&data);

    // 打印引用计数
    println!("Reference count after cloning: {}", Rc::strong_count(&data));

    // 离开作用域，引用计数减少
    {
        let _data_clone3 = Rc::clone(&data);
        println!("Reference count inside inner scope: {}", Rc::strong_count(&data));
    }

    // 离开作用域后，引用计数恢复
    println!("Reference count after inner scope: {}", Rc::strong_count(&data));

    // 离开 main 函数，引用计数降为零，数据被清理
}

在这个示例中，第17行，当离开一个作用域时，引用自动减少了。记数为零时，对象即被清理。

输出结果为：

Reference count after cloning: 3 Reference count inside inner scope: 4 Reference count after inner scope: 3

再看一个Arc示例：

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

fn main() {
    // 创建一个 Arc 实例，引用计数为 1
    let data = Arc::new(42);

    // 克隆 Arc，引用计数增加
    let data_clone1 = Arc::clone(&data);
    let data_clone2 = Arc::clone(&data);

    // 打印引用计数
    println!("Reference count after cloning: {}", Arc::strong_count(&data));

    // 创建线程
    let handle1 = thread::spawn(move || {
        println!("Thread 1: Data = {}", data_clone1);
    });

    let handle2 = thread::spawn(move || {
        println!("Thread 2: Data = {}", data_clone2);
    });

    // 等待线程完成
    handle1.join().unwrap();
    handle2.join().unwrap();

    // 打印引用计数
    println!("Reference count after threads: {}", Arc::strong_count(&data));

    // 离开 main 函数，引用计数降为零，数据被清理
}

Arc智能指针允许移动对象进入线程内，多个线程的引用消耗会自动同步。

Cell与RefCell

Cell充许在获取值的同时，还对值进行修改，这跳过了Rust的所有权规则。不过Cell仅针对实现了Copy的数据类型。示例：

use std::cell::Cell;

fn main() {
    // 创建一个 Cell，存储一个整数
    let value = Cell::new(42);

    // 获取 Cell 中的值（通过复制）
    println!("Initial value: {}", value.get());

    // 修改 Cell 中的值
    value.set(100);

    // 再次获取 Cell 中的值
    println!("Updated value: {}", value.get());

    // 通过 `get` 和 `set` 方法修改值
    let old_value = value.replace(200);
    println!("Replaced value: {}, Old value: {}", value.get(), old_value);

    // 使用 `into_inner` 获取 Cell 中的值（消耗 Cell）
    let final_value = value.into_inner();
    println!("Final value: {}", final_value);
}

这个示例会让Rust初学者感到疑惑，怎么，所有权规则不起作用了吗，一个值同时既可以获取又可以修改吗？但这种Cell仅针对实现了Copy特征的基本类型，例如上面的i32，实际上像i32这样的简单类型一般是没有必要使用Cell的。

输出为：

Initial value: 42 Updated value: 100 Replaced value: 200, Old value: 100 Final value: 200

Cell像一个世外桃园盒子，可以往里面存数据，也可以取数据，貌似还不受Rust所有权规则的约束。

RefCell用于没有实现Copy特征的，在它内部没有发生Copy，内存还是那一块内存，它只是将Rust编译器在编译时的警告延后了，如果在运行时违反了Rust规则，仍然会有panic异常。示例：

use std::cell::RefCell;

fn main() {
    // 创建一个 RefCell，存储一个 String
    let message = RefCell::new(String::from("Hello"));

    // 获取 RefCell 中的不可变引用
    {
        let msg = message.borrow();
        println!("Initial message: {}", *msg);
    } // 不可变引用离开作用域，释放借用

    // 获取 RefCell 中的可变引用并修改值
    {
        let mut msg = message.borrow_mut();
        msg.push_str(", world!");
    } // 可变引用离开作用域，释放借用

    // 再次获取 RefCell 中的不可变引用
    let msg = message.borrow();
    println!("Updated message: {}", *msg);

    // 尝试违反借用规则（会导致 panic）
    // let mut invalid_borrow = message.borrow_mut(); // 这里会 panic，因为已经有一个不可变引用
}

第24行，因为在第20行已经有一个不可变引用，所以这里不能再有一个可变引用，但这个错误不会在编译期报出来，只会在运行时报出来。第15行有一个可变借用，没有关系，因为到第17行它就释放了。这是使用RefCell的好处，可以跳过编译期严格的检查。

最终输出为：

Initial message: Hello Updated message: Hello, world!

RefCell可以方便地实现内部可变性，当我们不方便修改第三方特征签名的时候，用RefCell的borrow_mut方法，这样可以修改数据。

Rc+RefCell可以结合起来，实现多个变量都能获得可变引用，并进行数据修改的代码。示例：

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

fn main() {
    // 创建一个 Rc<RefCell<String>>，存储一个 String
    let data = Rc::new(RefCell::new(String::from("Hello")));

    // 克隆 Rc，增加引用计数
    let data_clone1 = Rc::clone(&data);
    let data_clone2 = Rc::clone(&data);

    // 修改 data_clone1 中的数据
    {
        let mut borrowed_data = data_clone1.borrow_mut();
        borrowed_data.push_str(", world!");
    } // 可变引用离开作用域，释放借用

    // 修改 data_clone2 中的数据
    {
        let mut borrowed_data = data_clone2.borrow_mut();
        borrowed_data.push_str(" How are you?");
    } // 可变引用离开作用域，释放借用

    // 打印最终的数据
    println!("Final data: {}", data.borrow());
}

Rust为了实现内存安全，在各个方向上围堵程序员的错误可能性，在实在没有办法的场景，仍然开放了像C++那样信任程序员的方法，给予了程序员自由。

Weak弱引用

Rc<T>中的T仍然受记数约束，只要记数不为0，它就不能被回收。Weak<T>不同，它不影响回收，它只是被动地使用，这种弱化的引用特别适合用于结构体中的自引用。对于Rc<T>，调用downgrade，可以得到一个Weak<T>，在Weak<T>上面调用upgrade方法，又可以得到一个Option<Rc<T>>，它可能是一个Rc<T>，也可以是None。

下面是一个使用了Weak弱引用的例子：

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

// 学生
struct Student {
    name: String,
    friends: RefCell<Vec<Weak<Student>>>,
}

impl Student {
    fn new(name: &str) -> Rc<Student> {
        Rc::new(Student {
            name: name.to_string(),
            friends: RefCell::new(Vec::new()),
        })
    }

    fn add_friend(&self, friend: &Rc<Student>) -> &Student {
        self.friends.borrow_mut().push(Rc::downgrade(friend));
        self
    }
}

fn main() {
    // 创建三个学生
    let xiaoli = &Student::new("小李");
    let xiaowang = &Student::new("小王");
    let xiaoming = &Student::new("小明");

    // 建立朋友关系
    xiaoli.add_friend(xiaoming).add_friend(xiaowang);
    xiaowang.add_friend(xiaoli).add_friend(xiaoming);
    xiaoming.add_friend(xiaoli).add_friend(xiaowang);

    // 打印每个学生的朋友
    let students = [xiaoli, xiaowang, xiaoming];
    for student in students.iter() {
        println!("{} 的朋友有:", student.name);
        for friend_opt in student.friends.borrow().iter() {
            if let Some(friend) = friend_opt.upgrade() {
                println!("  - {}", friend.name);
            } else {
                println!("  - <已删除的朋友>");
            }
        }
    }

    // 在 main 函数的最后，xiaoli, xiaowang, xiaoming 都会被销毁
    // 由于使用了 Weak<T>，避免了循环引用问题
}

第20行通过downgrade拿到了Weak<Studnet>。

最终输出为：

小李 的朋友有:
  - 小明
  - 小王
小王 的朋友有:
  - 小李
  - 小明
小明 的朋友有:
  - 小李
  - 小王

用裸指针实现结构体的自引用

下面是一个简单的示例，但却无法通过编译：

struct SelfRef<'a> {
    value: String,
    pointer_to_value: &'a str,
}

fn main() {
    let value = String::from("Hello, world!");
    let self_ref = SelfRef {
        value: value,
        pointer_to_value: &value[0..5],
    };
    println!("value: {}", self_ref.value);
    println!("pointer_to_value: {}", self_ref.pointer_to_value);
}

第9行，我们将value的所有权转移到了结构体SelfRef内，第10行，我们又企图用引用的方法划取value中的一部分，既有转移，又有引用，这在其他语言中是很平常的事情，在Rust中无法通过编译。

怎么解决？最简单的方法是在第9行上，给value加一个clone的尾巴。但今天我们不要这样做，示例：

struct SelfRef {
    value: String,
    pointer_to_value: *const String,
}

impl SelfRef {
    fn new(value: String) -> Self {
        let pointer_to_value = &value as *const String;
        Self {
            value,
            pointer_to_value,
        }
    }

    fn get_pointer_to_value(&self) -> &str {
        unsafe {
            &*self.pointer_to_value
        }
    }
}

fn main() {
    let mut self_ref = SelfRef::new("Hello,".to_string());
    println!("value: {}", self_ref.value);
    println!("pointer_to_value: {}", self_ref.get_pointer_to_value());
    self_ref.value.push_str("World!");
    println!("value: {}", self_ref.value);
    println!("pointer_to_value: {}", self_ref.get_pointer_to_value());
}

第8行，pointer_to_value是一个裸指针。第17行，使用unsafe修饰符将它指向的字符串返回。

输出：

value: Hello, pointer_to_value: Hello, value: Hello,World! pointer_to_value: Hello,

使用裸指针是实现有自引用字段的结构体的最简单、最优雅了方法了。

并发与并行的区别

如果将计算机的CPU比做咖啡的话，并发是计算机任务排成两个队或多个队，每个队轮流喝咖啡。而并行是排成两个队还多个队，每个队同时喝咖啡。

这是两个相似的概念，很容易搞混，英语单词也有所不同，并发是Concurrent，并行是 Parallel。

操作系统中的并发与并行

如果允许多个任务同时并发存在，那么这个系统就是并发系统；如果允许多个任务并行执行，那么这个系统就是并行系统。现代计算机往往有多个核心，同时现代操作系统也基本都允许多线程并发，线程与操作系统的核心构成了M:N的关系，表面上无论有多少M个任务在并发，实际上，在每一时刻，真正并行的只有N个。

运行时大小与三种并发模型

除了汇编语言，每种语言在编译成二进制文件的时候都有运行时，只是或大或小的问题。即使是Rust语言，它也有自己的运行时。运行时比较大的像Go语言，因为它本身实现了协程和GC，所以它的运行时比其它高级语言还更大一些。我们即使用Go语言实现一个只有Hello Word打印这样很小一个功能的程序，它发布的二进制包也不会很小。

高级语言在实现线程并发的方案上大致分为三种：

第一种像Rust，是一比一的实现，Rust里边的线程对应的就是操作系统里边的线程，是一比一的关系。

第二种是M:N的关系。代表语言是Go语言，这里的M要比N大，这是一种在语言层面实现的多线程，或者是称之为协程，或绿色线程。它的目的是为了用更小的系统资源实现更多的线程并发。

第三种是用Actor实现多线程，线程之间用信息同步。代表语言是Erlang。

Go语言采用协程的方式实现线程，是为了方便开发者。快速实现县城并发。并且是高效的实现。Ru没有采用，那是因为right的他想以更小的代价。恩，最小的占用运行时的这样一种方式。去实现多线程。并且像够远的那种。携程的实现方式在ru里面也有第三方库五实现了啊，叫Tokyo，开发者呢，其实是可以自行选择和使用的。包括类似于long around a模型啊，也是可以选择和使用的。

2025年03月11日

该文由 rustpress 编译。