Dive into Rust: Ownership, Borrowing, Lifetime

创建于更新于

最近在Rust中文论坛看到一位Java程序员的提问,主要是有关Rust所有权规则的理解问题,想了想,对于常用Java、Python这类有垃圾回收机制语言的程序员,Rust独特的内存安全机制确实较难理解。这篇博客准备总结一下我对Rust内存安全问题的理解,提供一些从Python分析Rust的视角,抛砖引玉。

常见内存安全问题

先列举一下一些常见的内存安全问题:

  • 缓冲区溢出
  • 解引用空指针
  • 访问未初始化内存
  • 错误释放
  • 释放后使用
  • 重复释放
  • ……

对于这些内存安全问题,一般常见的编程语言有以下解决方案:

  1. 程序员自己负责:C/C++系,通常是系统级编程语言的做法,程序员自己注意这些问题,优点是没有运行时负担,这也是为什么一般都是需要高性能的系统级语言采用这种做法,缺点很明显,高度依赖程序员的细心程度,一不小心就出问题,并且很有可能项目上线很久才会发现
  2. 垃圾回收:典型代表Java,由语言提供运行时管理内存,例如在一个值不会再被访问时释放该空间,优点是不需要程序员手动管理,心智负担小,缺点是牺牲了性能(其实还是会有内存泄漏等问题
  3. Rust:Rust表示鱼和熊掌要兼得,提倡零成本抽象,提供一套特定的规则,只有遵守规则的程序才能通过编译,在编译期解决内存安全问题,性能没有牺牲,程序员脑子也没有牺牲(大概

下面就聊一聊Rust用来保障内存安全的机制:所有权(Ownership)、借用(Borrowing)、生存期(Lifetime)

所有权

首先看一段Python代码:

import sys

class Foo:
    def __init__(self, value: int) -> None:
        self.value = value


a = Foo(3)
print(sys.getrefcount(a))
b = a
print(sys.getrefcount(a))

输出结果是2和3,Python的垃圾回收机制主要是基于引用计数,简单理解就是把变量看成对实际内存中值的一个引用,那么当这个引用数量为0时,这个值也就不需要了,可以从内存中清理掉。上面我们创建了Foo(3)这个值,赋值给a变量,这里结果是2,官方文档解释是因为在调用sys.getrefcount时参数作为临时变量引用,使引用计数被加了一次,后面又赋值a给了b,引用计数又加了1。

上面是Python中的规则,当然解释器实际的垃圾回收是很复杂的,还有一些其它辅助手段,但总之这个过程是没有我们人为干预的。

下面再看一段Rust代码:

#[derive(Debug)]
struct Student {
    name: String
}

fn print_student(student: Student) {
    println!("{:?}", student);
}

fn main() {
    let ming = Student { name: String::from("ming") };
    print_student(ming);
    let hong = &ming;  // 试着改成let hong = ming;再看报错
    println!("raw: {:?}, borrow: {:?}", ming, hong);
}

我特意写了个错误明显的程序,可以分别剖析,首先直接运行这段程序,看下编译器报错:

error[E0382]: borrow of moved value: `ming`
  --> src/main.rs:13:16
   |
11 |     let ming = Student { name: String::from("ming") };
   |         ---- move occurs because `ming` has type `Student`, which does not implement the `Copy` trait
12 |     print_student(ming);
   |                   ---- value moved here
13 |     let hong = &ming;  // 试着改成let hong = ming;再看报错
   |                ^^^^^ value borrowed here after move

Rust的编译器错误提示非常清晰,这里告诉我们,ming拥有类型Student的一个实例,在调用print_student(ming);时发生了“move”,并且还给了个提示说是因为我没有为其实现Copy trait,接着又告诉我们,在第13行尝试在发生“move”后借用这个值。对于不熟悉Rust的同学会觉得不知所有,这里先提一下Rust的所有权规则(来自《Rust程序设计语言》):

  1. Rust 中的每一个值都有一个被称为其 所有者owner)的变量。
  2. 值在任一时刻有且只有一个所有者。
  3. 当所有者(变量)离开作用域,这个值将被丢弃。

根据规则一,我们知道在定义变量ming的时候,ming就是实际的Student值的所有者,享有所有权,根据规则二,我们知道,在任何时候,Student实际值,都只能有一个主人,再回顾一下编译器提示:move occurs because ming has type Student, which does not implement the Copy trait。

对于Python程序:

a = [1, 2, 3, 4]
b = a
print(id(a), id(b))

Python中可以认为任何变量实质上都类似于C中的指针,只是指向实际值的一个标记,所以这里打印a和b指向的内存中的位置是相同的,a就是b。

而在Rust中:

fn main() {
    let ming = Student { name: String::from("ming") };
    let ming2 = ming; // 此时ming没用了
    // println!("{}", ming); 这行会报错
    println!("{:?}", ming2);
}

let ming2 = ming;,根据规则二,一个值同一时间只能有一个所有者,所以这里ming2成了所有者,所有权“move”了,ming不再存在,编译器提到了Copy,只有实现了Copy的数据类型,才会在这种重新赋值的场景下,不“move”所有权,而是复制一份新的值。

fn main() {
    let a = 1;
    let b = a;
    println!("a: {}, b: {}", a, b);
}

上面这段代码就不报错,因为Rust中一些基础类型是实现了Copy的,所以let b = a;的时候,b拥有所有权的是一个被复制出来的1,不违反规则二。

调用print_student函数,就是把ming的所有权“move”给了这个函数的参数这个变量,再看看规则三,首先什么是作用域呢?作用域就是一个值在程序中有效的范围:

{                      // s 在这里无效, 它尚未声明
    let s = "hello";   // 从此处起,s 是有效的

    // 使用 s
}                      // 此作用域已结束,s 不再有效

可以简单理解成Rust中任何值遇到右花括号}就被销毁死掉,Rust强制执行这一规则,那么在print_student函数结束的时候,实际的student值在内存中不复存在了,可是我们却要在这之后再次使用ming,于是编译器报错,但是注意,编译器给出的实际错误并不直接说student已经不复存在,而是说我borrowed after move,什么是borrow下一步说。

要解决这个问题,可以在print_student结束的时候用返回值,将所有权再还回来:

fn print_student(student: Student) -> Student {
    println!("{:?}", student);
    student
}

fn main() {
    let ming = Student { name: String::from("ming") };
    let ming = print_student(ming);
    let hong = &ming; // 这个时候ming还存在
    println!("raw: {:?}, borrow: {:?}", ming, hong);
}

这样就不会报错了,但是难道Rust中每个函数都必须将参数当做返回值返回吗?

还有一个办法:

#[derive(Debug, Clone)]
struct Student {
    name: String
}

fn print_student(student: Student) -> Student {
    println!("{:?}", student);
    student
}

fn main() {
    let ming = Student { name: String::from("ming") };
    print_student(ming.clone()); // 这里传入的是复制体
    let hong = &ming;
    println!("raw: {:?}, borrow: {:?}", ming, hong);
}

可以为Student实现Clone这个trait(关于Copy,有一套特殊规则,详见文档),在传入参数时显式调用clone方法,把复制体传进去。

但这样还要在每次调用函数时复制一份原有的值,还有其它方法吗?

借用

一般大学计算机相关专业会以C语言作为学生的入门语言,我们在学习C语言的时候,一般都会被告知使用malloc分配的内存,一定要记得free掉,程序运行的时候,不同的数据会使用不同的内存,如何在数据不再需要时,释放内存一直是一个麻烦的问题,忘了释放会浪费内存;释放过一次但程序员忘记了,再次释放,这是个未定义行为;数据后面还需要用却提前释放内存了,那更是可怕。前面我们提到Rust的所有权规则第三条,离开作用域就是释放内存,这听上去很简单,但从之前的代码中,这似乎会在一些场景下为我们带来麻烦。

前面我们已经提到了Rust中多个变量与数据之间的两种关系,分别是移动(move)与克隆(clone)。

let a = String::from("hello");
let b = a; // move

let a = String::from("hello");
let b = a.clone(); // clone

我们已经发现在使用函数时,所有权规则给我们带来了一些麻烦,于是Rust给我们提供了另一个机制。

    let hong = &ming; // 这个时候ming还存在

还记得这一行代码以及那个错误提示“value borrowed here after move”吗?&变量表示对变量的引用(reference),&ming创建了一个指向ming的引用,将它赋值给hong,hong并不会获得实际值的所有权,因此不违反所有权规则二,引用有些像C中的指针,但并不相同。

在讲引用前,要讲一下Rust变量的不可变性,在Python中,实际上是有不可变对象与可变对象之分的,但是没有不可以修改的变量这个概念(要想实现一个运行时不能被修改的类变量需要一些骚操作):

// 可以随意更改a的值和类型
a = 1
a = 2
a = "hello world"

因为变量只是一个“指针”,即使它指向的是不可变对象,也可以随意改变它所指向的数据。

let a = 1;
a = 3; // 错误

let a = 3; // 但是这种覆盖式的初始化是允许的

默认情况下,Rust定义一个变量之后就不允许对其进行修改,不仅是类型不可变,值也不能改。

let mut a = 1;
a = 2;

必须使用mut(mutable)关键字,显式标识这个值可以被修改。那么这和引用有什么关系呢?

以后端常说的增删改查来说,如果一个数据,需要被读取10次,这没太大问题,因为读这个操作没有副作用,不会改用数据本身,我们常说HTTP的GET方法具有幂等性也是这个原因,可以如果是修改呢?删除呢?

let a = 1;
let borrow_a = &a; // 不可变借用
let borrow_a1 = &a; // 没问题

let mut b = 1;
let mut_borrow_b = &mut b; // 可变借用
let mut_borrow_b1 = &mut b; // 错误

let c = 1;
let mut_borrow_c = &mut c; // 不行

对于不可变借用,可以有很多个,但同一时间可变变量的可变引用只能有一个,不可变数据没这个限制,因为它就不能有可变引用。

这一条规则避免了数据竞争

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

Rust直接避免了以上情况,有以上行为的程序无法编译通过。

Rust引用的另一条规则是,引用必须总是有效的,这个怎么理解呢?再看我们之前出错的程序,let hong = &ming;,hong是一个引用,在这之前ming已经在print_student函数中被销毁了,这在内存安全问题中一般被称为悬垂指针或悬垂引用,C语言中,一个指针指向的内存可能被你手动释放或者分配给其它数据了,但是这个指针没有被更改,程序可以编译通过,这会造成难以排查的bug。Rust在编译前避免这一点。

现在我们可以理解为什么编译器报错“borrowed after move”了。

那什么是借用呢?就是在函数使用引用做参数的时候称之为借用,我一般统统叫借用,有借有还,a借给b,所有权最终还在a那里,之前的函数可以这么改:

fn print_student(student: &Student) {
    println!("{:?}", student);
}

fn main() {
    let ming = Student { name: String::from("ming") };
    print_student(&ming);
    let hong = &ming;
    println!("raw: {:?}, borrow: {:?}", ming, hong);
}

参数使用&Student而不直接使用Student。

生存期

很多地方都喜欢把Rust中的Lifetime翻译成生命周期,但是我觉得这个Lifetime和life cycle并不是一个意思,而life cycle一般才被翻译成生命周期,lifetime还是叫生存期比较好。

什么是生存期呢?简单讲生存期基本上就是作用域,不过生存期一般是用来描述一个引用的作用范围,说白了就是一个引用可以合法的活多久。

那么结合上文引用的第二条规则,就能用生存期来描述了:引用的生存期,绝对不能大于其引用的值的作用域,直白说就是&a不能比a活得长。

{
    let r;                // ---------+-- 'a
                          //          |
    {                     //          |
        let x = 5;        // -+-- 'b  |
        r = &x;           //  |       |
    }                     // -+       |
                          //          |
    println!("r: {}", r); //          |
}  

以上程序来自《Rust程序设计语言》,根据所有权规则第三条,r从声明那一刻可以一直“活”到最后一个右花括号,而它引用的变量x,只能活到倒数第二个右花括号,这样的程序自然是无法通过编译的。

生存期注解

考虑这样一个函数:

fn main() {
    let a = 10;
    let b = 18;
    println!("max number is {}", max(&a, &b));
}

fn max(left: &i32, right: &i32) -> &i32 {
    if left > right {
        left
    } else {
        right
    }
}

编译器会告诉我们:

7 | fn max(left: &i32, right: &i32) -> &i32 {
  |              ----         ----     ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `left` or `right`
help: consider introducing a named lifetime parameter
  |
7 | fn max<'a>(left: &'a i32, right: &'a i32) -> &'a i32 {
  |       ^^^^       ^^^^^^^         ^^^^^^^     ^^^

编译器直接告诉我们要怎样修改程序:

fn max<'a>(left: &'a i32, right: &'a i32) -> &'a i32 {
    if left > right {
        left
    } else {
        right
    }
}

&'a i32这样的形式被称为生存期注解,这种情况下,我们告诉编译器,函数返回值至少会和两个参数里寿命最短的那个活一样长。这样编译器就能发现以下这种错误:

fn main() {
    let a = 10;
    let max_number;
    {
        let b = 18;
        max_number = max(&a, &b);
    }
    println!("max number is {}", max_number);
}

编译器会报错:

6 |         max_number = max(&a, &b);
  |                              ^^ borrowed value does not live long enough
7 |     }
  |     - `b` dropped here while still borrowed
8 |     println!("max number is {}", max_number);
  |                                  ---------- borrow later used here

编译器告诉我们这个借用活得不够长,如果这段程序被允许编译通过,那么就会造成悬垂引用问题了,如果a确实大于b那就还好,反过来,则会出现b被销毁,而b的借用还活着的情况。

在未来的Rust程序中,手动标记的生存期将会越来越少,编译器会自动帮我们推断出大部分情况下借用的生存期。

总结

下面是文章开头提到的那位Java程序员提问的代码:

struct InnerA {
}
struct InnerB<'a> {
    inner_a: &'a InnerA,
}
struct Outer {
    inner_a: InnerA,
    inner_b: InnerB,
}
fn main() {

    let inner_a = InnerA {};
    let inner_b = InnerB {
        inner_a: &inner_a,
    };

    let outer = Outer {
        inner_a,
        inner_b,
    };
    println!("OK");
}

编译器提示需要指定生存期,接着他改成了这样:

struct InnerA {
}
struct InnerB<'a> {
    inner_a: &'a InnerA,
}
struct Outer<'b> {
    inner_a: InnerA,
    inner_b: InnerB<'b>,
}
fn main() {

    let inner_a = InnerA {};
    let inner_b = InnerB {
        inner_a: &inner_a,
    };

    let outer = Outer {
        inner_a,
        inner_b,
    };
    println!("OK");
}

想必看到这里,读者已经能看出程序的错误之处以及如何修复了,当然具体的修改方式还得视需求而定。

Rust的内存安全机制还是比较独特的,尤其是熟悉Python这类语言的程序员初次接触会感到比较陌生。

在此总结一下:

  1. 数据同一时间有且只能有一个所有者,Python程序员尤其注意
  2. RAII,数据离开作用域立即被释放内存,Python程序员可以理解成语言层面的一个上下文管理器,离开with语句就调用__exit__方法
  3. 数据默认不可变,同一时间只能有一个可变引用,可以认为没有实际上的可变数据,只有共享数据与独占数据之分,一个数据能被多个人访问的时候不能变,只有有唯一可变引用或者没有引用的时候,这时候是**“独占”**的,所以可以安全地修改。
Copyright © 2020-2021 公子政的宅日常