一、主流语言的资源回收状况

计算机程序必须在运行时管理它们所使用的内存资源

C/C++ 这样的语言主要通过手动方式管理内存，开发者需要手动的申请和释放内存资源。但为了提高开发效率，只要不影响程序功能的实现，许多开发者没有及时释放内存的习惯。所以手动管理内存的方式常常造成资源浪费。

Java 语言也有回收资源的机制——GC，但是这种方式常常会降低运行时效率，所以 JVM 会尽可能少的回收资源，这样也会使程序占用较大的内存资源。

二、Rust 所有权

1、所有权概念的基础

所有权有以下三条规则：

Rust 中的每个值都有一个变量，称为其所有者。

一次只能有一个所有者。

当所有者不在程序运行范围时，该值将被删除。

从C/C++的角度来讲就是，变量有其作用范围，而且一个变量名对应一个变量的值；超过变量作用范围，该值就失效了。

2、根据变量来理清内存分配

2.1. 变量范围与内存分配

变量范围

变量范围是变量的一个属性，其代表变量的可行域，默认从声明变量开始有效直到变量所在域结束。

内存和分配

如果我们定义了一个变量并给它赋予一个值，则这个变量的值存在于内存中。这种情况很普遍，但如果我们需要储存的数据长度不确定（比如用户输入的一串字符串），我们就无法在定义时明确数据长度，也就无法在编译阶段令程序分配固定长度的内存空间供数据储存使用。（有人说分配尽可能大的空间可以解决问题，但这个方法很不文明）。这就需要提供一种在程序运行时程序自己申请使用内存的机制——堆。

有分配就有释放，程序不能一直占用某个内存资源。因此决定资源是否浪费的关键因素就是资源有没有及时的释放。

用 C++代码举例：

int n = 0;
  cin >> n;
  int* arr = new int[n];
  delete []arr;

很显然，Rust 里没有delete 函数来释放arr的内存资源。而Rust 之所以没有明示释放的步骤是因为在变量范围结束的时候，Rust 编译器自动添加了调用释放资源函数的步骤。别小看这一个自动调用释放资源的机制，这种简单的机制可以有效地解决一个史上最令程序员头疼的编程问题。

2.2、变量与数据交互的方式

变量与数据交互方式主要有移动（Move）和克隆（Clone）两种：

多个变量可以在 Rust 中以不同的方式与相同的数据交互——移动

例：let x = 5; let y = x;

这个程序将值 5 绑定到变量 x，然后将 x 的值复制并赋值给变量 y。现在栈中将有两个值 5。此情况中的数据是"基本数据"类型的数据，不需要存储到堆中，仅在栈中的数据的"移动"方式是直接复制，这不会花费更长的时间或更多的存储空间。

基本数据类型：

所有整数类型，例如 i32 、 u32 、 i64 等。

布尔类型 bool，值为 true 或 false 。

所有浮点类型，f32 和 f64。

字符类型 char。

仅包含以上类型数据的元组（Tuples）

但如果发生交互的数据在堆中就是另外一种情况：

let s1 = String::from("hello");

let s2 = s1;

第一步是产生一个 String 对象，值为 “hello”。其中 “hello” 可以认为是类似于长度不确定的数据，需要在堆中存储，而第二步s2指向堆内s1的地址，放在C/C++里来说，这时候访问s1和s2都能得到“Hello”这个结果，但是在Rust里不允许这样。

前面我们说过，当变量超出范围时，Rust 自动调用释放资源函数并清理该变量的堆内存。但是 s1 和 s2 都被释放的话堆区中的 “hello” 被释放两次，这是不被系统允许的，实际上，当s1赋值给s2时，s1已经是名存实亡的状态了(无法访问)。

Rust会尽可能地降低程序的运行成本，所以默认情况下，长度较大的数据存放在堆中，且采用移动的方式进行数据交互。但如果需要将数据单纯的复制一份以供他用，可以使用数据的第二种交互方式——克隆。

实例：

fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone();
    println!("s1 = {}, s2 = {}", s1, s2);
}

这里是真的将堆中的 “hello” 复制了一份，所以 s1 和 s2 都分别绑定了一个值，释放的时候也会被当作两个资源。

当然，克隆仅在需要复制的情况下使用，毕竟复制数据会花费更多的时间。

3、涉及函数的所有权机制

3.1、函数传参的所有权

我们直接用代码解释：

fn main() {
    let s = String::from("hello");
    // s 被声明有效
    takes_ownership(s);
    // s 的值被当作参数传入函数
    // 所以可以当作 s 已经被移动，从这里开始已经无效
    let x = 5;
    // x 被声明有效
    makes_copy(x);
    // x 的值被当作参数传入函数
    // 但 x 是基本类型，依然有效
    // 在这里依然可以使用 x 却不能使用 s
} // 函数结束, x 无效, 然后是 s. 但 s 已被移动, 所以不用被释放
fn takes_ownership(some_string: String) {
    // 一个 String 参数 some_string 传入，有效
    println!("{}", some_string);
} // 函数结束, 参数 some_string 在这里释放
fn makes_copy(some_integer: i32) {
    // 一个 i32 参数 some_integer 传入，有效
    println!("{}", some_integer);
} // 函数结束, 参数 some_integer 是基本类型, 无需释放

3.2、函数返回值的所有权机制

上实例：

fn main() {
    let s1 = gives_ownership();
    // gives_ownership 移动它的返回值到 s1
    let s2 = String::from("hello");
    // s2 被声明有效
    let s3 = takes_and_gives_back(s2);
    // s2 被当作参数移动, s3 获得返回值所有权
} // s3 无效被释放, s2 被移动, s1 无效被释放.
fn gives_ownership() -> String {
    let some_string = String::from("hello");
    // some_string 被声明有效
    return some_string;
    // some_string 被当作返回值移动出函数
}
fn takes_and_gives_back(a_string: String) -> String { 
    // a_string 被声明有效
    a_string  // a_string 被当作返回值移出函数
}

被当作函数返回值的变量所有权将会被移动出函数并返回到调用函数的地方，而不会直接被无效释放。

4、引用与租借

Rust 语言也是支持引用的，这个知识点对于C++开发者来说可谓是非常熟悉，引用实质上是一种指针，具体来说是一个指针常量。

 我们可以把引用理解为访问变量的间接方式：

fn main() {
    let s1 = String::from("hello");
    let s2 = &s1;
    println!("s1 is {}, s2 is {}", s1, s2);
}
//变量本身不会被认定无效，可以访问s1，因为"引用"并没有在栈中复制变量的值

在函数中，传入变量的引用只需加上&即可：

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}.", s1, len);
}
fn calculate_length(s: &String) -> usize {
    s.len()
}
运行结果：The length of 'hello' is 5.

关于引用时所有权的问题：

引用不会获得值的所有权。

引用只能租借（Borrow）值的所有权。

引用本身也是一个类型并具有一个值，这个值记录的是别的值所在的位置（地址），但引用不具有所指值的所有权。

一个引用必须租借拥有所有权的变量，如果被租借的变量所有权移交给其他变量，那么就需要重新对新变量租借。

 例如：

let s1 = String::from("hello");
    let mut s2 = &s1; //因为s2租借多次，所以需要加mut
    let s3 = s1;
    s2 = &s3;  //重新从 s3 租借所有权

如果尝试利用租借来的权利来修改数据会被阻止，如果想要修改就要加上mut关键字

例如：

可变引用与不可变引用相比除了权限不同以外，可变引用不允许多重引用，但不可变引用可以

 例如：

let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s;
println!("{}, {}", r1, r2);

这段程序不正确，因为多重可变引用了 s。

Rust 对可变引用的这种设计主要出于对并发状态下发生数据访问碰撞的考虑，在编译阶段就避免了这种事情的发生。

由于发生数据访问碰撞的必要条件之一是数据被至少一个使用者写且同时被至少一个其他使用者读或写，所以在一个值被可变引用时不允许再次被任何引用。

垂悬引用（Dangling References）

在C/C++等有指针概念的语言里，会存在空指针和野指针的异常，其实这种异常指的是那种没有实际指向一个真正能访问的数据的指针。它们就像失去悬挂物体的绳子，所以叫"垂悬引用" 。

下面是一个垂悬的典型案例：

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

主函数调用dangle函数，该函数定义了一个局部变量 s ，函数结束时返回的该变量的引用；但是该变量本身并没有当作返回值，而是超过作用域后被释放，那么此时的引用的指向已经无法确定是否存在，因此不允许存在。

这个原理跟C++中不能返回局部变量的地址是同一个知识点。