理解 Rust 中的引用和借用

Rust 中的引用和借用概念与指针的使用有一些相似之处。

在 Rust 中，引用是一种允许访问数据但不拥有其所有权的方式。通过引用，你可以借用其他变量的值而不会转移其所有权。

**引用（reference）**像一个指针，因为它是一个地址，我们可以由此访问储存于该地址的属于其他变量的数据。与指针不同，引用确保指向某个特定类型的有效值
我们将创建一个引用的行为称为 借用（borrowing）。正如现实生活中，如果一个人拥有某样东西，你可以从他那里借来。当你使用完毕，必须还回去。我们并不拥有它

在 Rust 中，引用分为两种：**可变引用（mutable references）**和 不可变引用（immutable references）。可变引用允许对数据进行修改，而不可变引用只能读取数据，不能修改。这种限制使得 Rust 在编译时可以进行更严格的内存安全检查。

下面是不可变引用的示例：

rust 复制代码

fn main() {
    let s1 = String::from("hello");

    // 这里 `&s1` 创建了不可变引用
    let len = calculate_length(&s1);

    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

如果尝试修改借用的变量，则会直接报错：

rust 复制代码

fn main() {
    let s = String::from("hello");

    change(&s);
}

fn change(some_string: &String) {
    some_string.push_str(", world");
}

javascript 复制代码

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0596]: cannot borrow `*some_string` as mutable, as it is behind a `&` reference
 --> src/main.rs:8:5
  |
7 | fn change(some_string: &String) {
  |                        ------- help: consider changing this to be a mutable reference: `&mut String`
8 |     some_string.push_str(", world");
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `some_string` is a `&` reference, so the data it refers to cannot be borrowed as mutable

For more information about this error, try `rustc --explain E0596`.
error: could not compile `ownership` due to previous error

如果需要修改一个借用的值，正确的做法是改为可变引用：

rust 复制代码

fn main() {
    // 这里需要改用 `mut`
    let mut s = String::from("hello");

    // 创建可变引用
    change(&mut s);
}

fn change(some_string: &mut String) {
    // 函数签名也需要改为接收可变引用 `some_string: &mut String`
    // 这就非常清楚地表明，`change` 函数将改变它所借用的值
    some_string.push_str(", world");
}

与传统的指针相比，Rust 的引用有一些附加的安全性保证。其中最重要的是，Rust 在编译时检查引用的有效性，以防止 **悬垂指针（dangling pointers）**和 **数据竞争（data races）**等内存安全问题。

Rust 如何解决 data race 问题

可变引用有一个很大的限制：如果你有一个对该变量的可变引用，你就不能再创建对该变量的引用。这些尝试创建两个 s 的可变引用的代码会失败：

rust 复制代码

let mut s = String::from("hello");

let r1 = &mut s;
let r2 = &mut s;

println!("{}, {}", r1, r2);

错误如下：

lua 复制代码

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0499]: cannot borrow `s` as mutable more than once at a time
 --> src/main.rs:5:14
  |
4 |     let r1 = &mut s;
  |              ------ first mutable borrow occurs here
5 |     let r2 = &mut s;
  |              ^^^^^^ second mutable borrow occurs here
6 |
7 |     println!("{}, {}", r1, r2);
  |                        -- first borrow later used here

For more information about this error, try `rustc --explain E0499`.
error: could not compile `ownership` due to previous error

这个报错说这段代码是无效的，因为我们不能在同一时间多次将 s 作为可变变量借用。第一个可变的借入在 r1 中，并且必须持续到在 println! 中使用它，但是在那个可变引用的创建和它的使用之间，我们又尝试在 r2 中创建另一个可变引用，该引用借用与 r1 相同的数据。

这一限制以一种非常小心谨慎的方式允许可变性，防止同一时间对同一数据存在多个可变引用。新 Rustacean 们经常难以适应这一点，因为大部分语言中变量任何时候都是可变的。这个限制的好处是 Rust 可以在编译时就避免数据竞争。**数据竞争（data race）**类似于竞态条件，它可由这三个行为造成：

两个或更多指针同时访问同一数据。
至少有一个指针被用来写入数据。
没有同步数据访问的机制。

数据竞争会导致未定义行为，难以在运行时追踪，并且难以诊断和修复；Rust 避免了这种情况的发生，因为它甚至不会编译存在数据竞争的代码！

这里补充一下，虽然 Go 语言没有类似内存安全指针，但是 Go 语言提供了内置的 data race 检测，在运行命令的时候加上 -race 参数就行：

bash 复制代码

$ go test -race mypkg    // to test the package
$ go run -race mysrc.go  // to run the source file
$ go build -race mycmd   // to build the command
$ go install -race mypkg // to install the package

Rust 如何解决指针悬挂问题

在具有指针的语言中，很容易通过释放内存时保留指向它的指针而错误地生成一个 悬垂指针（dangling pointer），所谓悬垂指针是其指向的内存可能已经被分配给其它持有者。相比之下，在 Rust 中编译器确保引用永远也不会变成悬垂状态：当你拥有一些数据的引用，编译器确保数据不会在其引用之前离开作用域。

让我们尝试创建一个悬垂引用，Rust 会通过一个编译时错误来避免：

rust 复制代码

fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String {
    let s = String::from("hello");

    &s
}

这里是错误：

vbnet 复制代码

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0106]: missing lifetime specifier
 --> src/main.rs:5:16
  |
5 | fn dangle() -> &String {
  |                ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime
  |
5 | fn dangle() -> &'static String {
  |                 +++++++

For more information about this error, try `rustc --explain E0106`.
error: could not compile `ownership` due to previous error

因为 s 是在 dangle 函数内创建的，当 dangle 的代码执行完毕后，s 将被释放。不过我们尝试返回它的引用。这意味着这个引用会指向一个无效的 String，这可不对！Rust 不会允许我们这么做。

Rust 不允许函数返回对局部变量的引用。一种解法是直接返回被引用对象的所有权：

rust 复制代码

fn no_dangle() -> String {
    let s = String::from("hello");

    s
}

另一种解法是使用 Box 来在堆上分配内存并返回一个指针：

rust 复制代码

fn dangle() -> Box<String> {
    let s = String::from("hello");

    Box::new(s)
}

注意，这里的 Box 是一种智能指针，它允许将数据分配在堆上，并在函数返回后继续保持有效。

这里补充一下，Go 语言允许在函数中返回局部变量引用，这种情况下，函数虽然退出了，但是因为指针的存在，对象的内存不能随着函数结束而回收（避免指针悬挂），因此只能分配在堆上。

go 复制代码

type Demo struct {
  name string
}

func createDemo(name string) *Demo {
  d := new(Demo) // 局部变量 d 逃逸到堆
  d.name = name
  return d
}

func main() {
  demo := createDemo("demo")
  fmt.Println(demo)}
}

Go 是通过在编译器里做逃逸分析（escape analysis）来决定一个对象放栈上还是放堆上，不逃逸的对象放栈上，可能逃逸的放堆上。对于 Go 来说，我们可以通过下面指令来看变量是否逃逸：

bash 复制代码

$ go run -gcflags '-m -l' main.go

-m 会打印出逃逸分析的优化策略，实际上最多总共可以用 4 个 -m，但是信息量较大，一般用 1 个就可以了。 -l 会禁用函数内联，在这里禁用掉内联能更好的观察逃逸情况，减少干扰

总结

最后谈谈个人想法，在 JS 或者 Java 里面，一个函数返回一个对象（引用类型）是很正常的操作，但实际上在 Go 或者 Rust 里面会有大问题。因为 JS 不允许开发者操作指针，这样运行时就可以做一些简单的设定，比如基本类型都用值传递，引用类型都用指针传递；基本类型默认分配在栈内存，引用类型默认分配在堆内存。但是在 Go 语言中，即使基本类型也可以操作指针，因此这种策略行不通了。在 Go 语言中，任何类型（包括引用类型）都会 倾向于 分配在栈内存，因为栈的内存是由编译器自动进行分配和释放的，非常高效，它们随着函数的创建而分配，随着函数的退出而销毁；而对于堆上的内存回收，得通过Go的三色标记法，进行垃圾回收，并且有时还需要加锁来防止多线程冲突。这里会有个问题，比如一个函数返回了一个局部变量的指针，为了防止出现指针悬挂问题，变量不能在函数退出的时候回收，因此编译器的策略是将该变量逃逸到堆内存上（在 Rust 中需要开发者手动用 Box 指针）。

总结一下，在 Rust 中，内存安全是一种编译时的保证，它可以防止常见的内存错误，如悬垂指针、空指针解引用和数据竞争。需要注意的是，实际上 Go 语言也提供了相应的解决方案。个人觉得还是 Go 语言更好，至少不用一上手就了解一大堆概念，比如并发同步原语、内存模型、逃逸分析这些，可以一边用一边学。但是在 Rust 里面就不行，如果这些不了解就没法开发了。

参考：

doc.rust-lang.org/book/ch04-0...

kaisery.github.io/trpl-zh-cn/...