《深入Rust系统编程》5.1 所有权与借用检查器

5.1 所有权与借用检查器

Rust 的所有权系统是其内存安全的核心机制，它通过严格的规则确保程序在编译时就能够避免常见的内存错误（如空指针、野指针、数据竞争等）。所有权系统与借用检查器共同构成了 Rust 的内存安全基础，使得 Rust 能够在没有垃圾回收的情况下实现高效、安全的内存管理。

5.1.1 所有权系统的基本概念

所有权系统是 Rust 最独特的功能之一，它通过以下三条规则确保内存安全：

  1. 每个值都有一个所有者。
    值的所有者负责管理该值的内存生命周期。当所有者离开作用域时，值的内存会被自动释放。

  2. 值在同一时间只能有一个所有者。
    这意味着 Rust 不允许多个变量同时拥有对同一块内存的控制权，从而避免了数据竞争和内存冲突。

  3. 可以通过移动（move）或借用（borrow）来转移或共享值的所有权。

    • 移动（Move）： 将值的所有权从一个变量转移到另一个变量，原变量将不再有效。
    • 借用（Borrow）： 允许变量临时借用值的引用，而不转移所有权。

1. 所有权的转移

当一个值被赋值给另一个变量时，Rust 会将该值的所有权转移到新变量，原变量将不再有效。以下是一个所有权转移的示例：

1
2
3
4
5
6

fn main() {
    let s1 = String::from("hello"); // s1 拥有字符串 "hello" 的所有权
    let s2 = s1; // s1 的所有权转移到 s2
    // println!("{}", s1); // 错误！s1 不再有效
    println!("{}", s2); // 输出 "hello"
}

2. 所有权的释放

当值的所有者离开作用域时，值的内存会被自动释放。以下是一个所有权释放的示例：

1
2
3
4
5
6
7

fn main() {
    {
        let s = String::from("hello"); // s 进入作用域
        println!("{}", s); // 输出 "hello"
    } // s 离开作用域，内存被释放
    // println!("{}", s); // 错误！s 不再有效
}

5.1.2 借用与引用

为了避免所有权的转移，Rust 提供了借用机制，允许变量临时借用值的引用。借用分为两种：

  • 不可变借用（Immutable Borrow）： 允许读取值，但不能修改值。
  • 可变借用（Mutable Borrow）： 允许读取和修改值。

1. 不可变借用

不可变借用通过 & 符号实现，允许多个变量同时借用值的引用。以下是一个不可变借用的示例：

1
2
3
4
5
6
7
8
9

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1); // 不可变借用 s1
    println!("The length of '{}' is {}.", s1, len); // 输出 "The length of 'hello' is 5."
}

fn calculate_length(s: &String) -> usize {
    s.len() // 读取值，但不修改值
}

2. 可变借用

可变借用通过 &mut 符号实现，只允许一个变量借用值的可变引用。以下是一个可变借用的示例：

1
2
3
4
5
6
7
8
9

fn main() {
    let mut s = String::from("hello");
    change(&mut s); // 可变借用 s
    println!("{}", s); // 输出 "hello, world"
}

fn change(s: &mut String) {
    s.push_str(", world"); // 修改值
}

3. 借用规则

Rust 的借用检查器会强制执行以下规则，以确保内存安全：

  • 在任意给定时间，要么只能有一个可变借用，要么只能有多个不可变借用。
    这条规则防止了数据竞争，确保同一时间不会有多个变量同时修改同一块内存。
  • 借用必须始终有效。
    引用的生命周期不能超过被引用值的生命周期，否则会导致悬垂指针。

以下是一个违反借用规则的示例：

1
2
3
4
5
6

fn main() {
    let mut s = String::from("hello");
    let r1 = &mut s;
    let r2 = &mut s; // 错误！同一时间只能有一个可变借用
    println!("{}, {}", r1, r2);
}

5.1.3 生命周期

生命周期是 Rust 用来确保引用始终有效的机制。生命周期注解用于指定引用的有效范围，防止悬垂指针。

1. 生命周期注解

生命周期注解使用单引号 (') 表示，例如 'a。以下是一个使用生命周期注解的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let string1 = String::from("long string is long");
    let string2 = "xyz";
    let result = longest(string1.as_str(), string2);
    println!("The longest string is {}", result); // 输出 "The longest string is long string is long"
}

在这个例子中，'a 是一个生命周期参数，它表示 x 和 y 的引用必须具有相同的生命周期，并且返回的引用也具有相同的生命周期。

2. 生命周期省略规则

在某些情况下，Rust 可以自动推断生命周期，而无需显式注解。以下是一些生命周期省略规则的示例：

  • 每个引用参数都有自己的生命周期参数。
    例如，fn foo(x: &i32, y: &i32) 会被推断为 fn foo<'a, 'b>(x: &'a i32, y: &'b i32)。
  • 如果只有一个输入生命周期参数，则该生命周期被赋予所有输出生命周期参数。
    例如，fn foo(x: &i32) -> &i32 会被推断为 fn foo<'a>(x: &'a i32) -> &'a i32。
  • 如果有多个输入生命周期参数，但其中一个参数是 &self 或 &mut self，则 self 的生命周期被赋予所有输出生命周期参数。
    例如，impl Foo { fn bar(&self, x: &i32) -> &i32 } 会被推断为 impl Foo { fn bar<'a>(&'a self, x: &i32) -> &'a i32 }。

5.1.4 借用检查器的工作原理

借用检查器是 Rust 编译器的一部分，它在编译时检查代码是否符合所有权和借用规则。借用检查器的主要任务是：

  1. 跟踪值的所有权和生命周期。
    借用检查器会记录每个值的所有者以及引用的生命周期。
  2. 检查借用规则是否被违反。
    借用检查器会确保在同一时间内，要么只能有一个可变借用，要么只能有多个不可变借用。
  3. 防止悬垂引用。
    借用检查器会确保引用的生命周期不超过被引用值的生命周期。

以下是一个借用检查器的工作示例：

1
2
3
4
5
6
7

fn main() {
    let mut s = String::from("hello");
    let r1 = &s; // 不可变借用
    let r2 = &s; // 不可变借用
    // let r3 = &mut s; // 错误！同一时间不能有可变借用和不可变借用
    println!("{}, {}", r1, r2);
}

在这个例子中，借用检查器会阻止 r3 的可变借用，因为 r1 和 r2 已经不可变借用了 s。

5.1.5 所有权与借用检查器的优势

Rust 的所有权系统和借用检查器具有以下优势：

  1. 内存安全： 通过编译时检查，Rust 可以避免常见的内存错误（如空指针、野指针、数据竞争等）。
  2. 无需垃圾回收： Rust 的所有权系统在编译时管理内存，避免了运行时垃圾回收的开销。
  3. 高性能： Rust 的内存管理机制使得程序可以高效地运行，接近 C/C++ 的性能。
  4. 并发安全： Rust 的所有权系统和借用检查器可以防止数据竞争，使得并发编程更加安全。

5.1.6 总结

Rust 的所有权系统和借用检查器是其内存安全的核心机制，它们通过严格的规则确保程序在编译时就能够避免常见的内存错误。所有权系统通过管理值的生命周期和转移规则，确保内存的正确释放；借用检查器通过检查引用规则，防止数据竞争和悬垂指针。理解所有权与借用检查器的工作原理，对于编写安全、高效的 Rust 程序至关重要。通过合理地使用所有权和借用机制，可以构建出高性能、高可靠性的 Rust 应用程序。