Rust 所有权和借用

Rust之所以可以成为万众瞩目的语言, 就是因为其内存安全性. 在以往内存安全几乎全都是通过GC的方式实现, 但是GC会引来性能、CPU以及Stop The World等问题, 在需要高性能的场景是不可以接受的，因此Rust使用一种与众不同的方式 解决内存安全问题: 所有权机制

Rust所有权

所有程序都必须和计算机的内存打交道, 如何从RAM中申请空间存放程序运行所需要的数据, 在不需要是回收内存空间, 成为了关键, 在计算机编程语言不断进化的过程中出现了三种解决方案:

• 垃圾回收机制(GC) , 程序运行时RunTime 通过三色标记 引用计数 分代回收等算法 回收空闲内存 : Go Python Java

• 手动管理内存的分配和释放, 编写通过函数调用的方式申请释放内存 ： C malloc() free(), C++ new() delete()

• 通过所有权机制管理内存, 在程序编译期间 确定内存申请 释放的时间, 将相关的数据硬编码到二进制程序中, 在程序运行期间不会有任何性能上的损耗

一段内存不安全的代码

int* foo() {
    int a;          // 变量a的作用域开始
    a = 100;
    char *c = "xyz";   // 变量c的作用域开始
    return &a;
}                   // 变量a和c的作用域结束

​ 这段C代码是可以顺利编译通过的 foo函数返回一个int指针类型, 但是变量a和c是foo函数内的局部变量, 我们都知道 函数和函数内的局部变量 都是存储在栈当中的, 当foo函数执行完成后 局部变量a，c及函数foo 在栈内申请的内存 就已经被回收了, 此时返回变量a的指针, 从而形成了悬空指针 (悬垂指针, 野指针) 因为a申请的内存数据在foo函数结束是已经被回收, 此时返回a的指针 指向的内存地址已经被回收或者被其他程序使用, 如果这块地址再次被其他程序申请到并放入数据, 那就跟我们程序预期的效果产生差异,容易导致程序崩溃.

例如: a程序中a的数据是100 , 回收后被其他程序申请存入数据为 "malloc"。

​ 我们再来看一下变量c, 变量c的问题在于内存的浪费, 也是对栈的空间的浪费, c变量申请的内存在他声明完成后没有任何操作, 但是他回收的时间需要在foo函数结束是才进行回收 产生了资源的浪费

​ 内存安全的问题一直都是令开发者头疼的问题, 所以如何保证内存安全成为我们对技术深度评判标准之一, Rust的所有权机制将解决大部分内存安全问题, 想要保证内存安全我们就需要对 堆 栈有足够的认知

堆 和 栈

堆和栈是编程语言最核心的两个数据结构, 在许多编程语言我们不需要深入了解, 因为GC会偷偷的无感知的帮我们进行内存的回收, 这也意味着性能的瓶颈, 但是对于Rust这种系统编程语言, 数据值位于栈 或 堆 上是很重要的, 因为他大大的影响程序运行时的性能

堆栈实际上都是我们RAM

栈

栈 是按照顺序且连续存储值 并以相反的数据取值, 先进后出, 存储数据为进栈 , 取出数据为出栈。 栈中的数据值所申请的内存大小必须是已知的固定的内存空间, 如果数据值大小是未知的, 那么取出数据时, 你无法取出你想要的数据。

栈 通常存储的数据是 编程语言的内置的基本类型的数据 i32 i64 f32 f64 &str bool 、 函数、 函数内的局部变量 、堆指针地址、元祖

ulimit -s 用于查看操作系统的栈空间 间接的说明栈空间是有限的 如果申请栈内存空间超出栈 就会发生栈溢出 程序崩溃、Go内存逃逸分析 等场景

每一个程序运行时操作系统都会为其分配栈的内存空间 1-8M , 通常情况下不会出现栈溢出 如果出现死循环、深递归的时候就极有可能出现程序崩溃。

堆

对比着栈来理解堆 更容易理解一些

栈是由cpu寄存器来访问控制回收, 堆是由开发者来控制堆内存的回收

栈中存储的数据值都是已知大小的数据, 堆内可以存储未知大小的动态数据 相对灵活 .

栈申请的内存用完立即释放, 堆内存需要根据生命周期和GC算法释放内存

栈是连续的内存空间, 堆是不连续的 很有可能会产生内存碎片 无法回收造成浪费

栈的空间是有限的, 堆的空间可以认为是无限的

栈为什么会比堆快

1.cpu高速缓存会缓存栈内的数据 不会缓存堆内的数据 跟他们的存储规则有关

2.栈是直接寻址 申请只存只需要移动一个指针即可, 堆是间接寻址的 首先要去栈内取得变量的堆指针, 才可以获取数据。

3.栈是由cpu的寄存器直接访问控制的

4.栈在程序开始运行就已经开辟好了内存空间, 而堆需要在程序运行时 运行到对应到指定位置才开辟内存空间

5.入栈比堆分配内存快, 因为入栈操作系统无需分配新的内存空间,只需将新数据放入栈顶

所有权原则

在理解堆栈的前提下, 更有利理解Rust的所有权

1.Rust中的每一个值 有且只有一个所有者(变量)

let s = String::from("teststr")  // 变量s就是字符串teststr的所有者

2.当所有者(变量)离开作用域范围时，这个值将被丢弃(free) 也就是释放内存空间

fn test() {
  let s = String::from("teststr")  // s为test函数中的局部变量
} // 函数执行完成  变量s 离开作用域 字符串teststr的内存将被释放 生命周期结束

简单介绍String类型

上边提到了String::from 方法 , 创建变量的类型是String

let s = String::from("teststr")  // 变量s就是字符串teststr的所有者

还有一种声明字符串的例子 这种声明的字符串类型是 字符串字面值 a 是被硬编码到程序的类型是&str 他不可修改

let a = "test"

所有权背后的数据交互

下面看这样一段代码

let x = 5;  // x 变量就是 整数5的所有者
let y = x;  // 拷贝 x 赋值给 y  最终x和y都等于5  且都可以调用 因为上述操作都是在栈中运作的 整数类型是rust的基本类型 基本类型赋值调用都会自动拷贝 不会在堆中进行分配使用  也不会引发所有权机制

// 可能有好奇宝宝 会想 这种栈中的的copy赋值 是不是太慢了些, 但是实际上在rust的基本类型足够简单 ,拷贝会非常快, 只需要赋值一个i32，4字节的内存即可

随即看这样一段代码：

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

println!("{}{}", s1, s2)
// 跟上边的整型拷贝很像吧 但是 String类型 并不是rust的基本类型  所以他是存放在堆上的 不会自动拷贝 此时打印s1,s2就会触发rust的所有权机制

// 我们可以先看一下上边这段代码具体发生了什么
//String类型是一个复杂的类型, 他的堆指针、字符串长度、字符串容量共同存放在栈中, 真实数据存放在堆中,下面我们分析 let s2 = s1 可能出现的两种情况
	1.拷贝栈上String堆指针 容量 长度 和存储在堆上的字节数组, 这就是深拷贝了
	2.只拷贝String的堆指针 容量 长度 8+8+8字节 理解为浅拷贝, 但是这样就跟Rust所有者机制产生了冲突  因为我们的数据的所有者有且只能有一个, 如果按照这种浅拷贝的情况 那么这个数据就出现了两个所有者, 那么当s1和s2离开作用域的时候都会释放同一块内存, 也称为二次释放, 导致内存污染 违背了Rust的所有权机制, 那么Rust是如何处理这种问题呢? 解决方法: 
	当s1将值赋值给s2的时候, Rust认为s1不再有效, 因此也无需在s1离开作用域后drop释放s1的内容, s1的数据的所有权已经转移给了s2, s1同时也就失效了, 不会产生二次释放的问题, 效率大大增加,

上图中就是第二中浅拷贝的情况rust解决的方案, s1赋值给s2后 s1自动失效, s2接管这块内存地址

深拷贝

Rust永远不会自动创建数据的"深拷贝", 因此, 任何的自动复制都不是深拷贝. 浅拷贝被认为运行时性能影响较小

let s1 = String::from("hehahi");
let s2 = s1.clone();  // 深拷贝
println!("{}{}", s1, s2)

此段代码编译运行畅通无阻, 因为s2 完成的clone了s1 包括栈内的堆指针 容量 长度 堆内的数据, 但是如果频繁使用clone深拷贝 将会带来性能上的降低。

函数参数传递及返回 所有权的转移

在变量作为参数传递给函数是, 同样会发生移动或者复制, 所有权就会对应的产生变化

fn main() {
    let s = String::from("hello");  // s 进入作用域

    takes_ownership(s);             // s 的值移动到函数里 ...
                                    // ... 所以到这里不再有效

    let x = 5;                      // x 进入作用域

    makes_copy(x);                  // x 应该移动函数里，
                                    // 但 i32 是 Copy 的，所以在后面可继续使用 x

} // 这里, x 先移出了作用域，然后是 s。但因为 s 的值已被移走，
  // 所以不会有特殊操作

fn takes_ownership(some_string: String) { // some_string 进入作用域
    println!("{}", some_string);
} // 这里，some_string 移出作用域并调用 `drop` 方法。占用的内存被释放

fn makes_copy(some_integer: i32) { // some_integer 进入作用域
    println!("{}", some_integer);
} // 这里，some_integer 移出作用域。不会有特殊操作

我们如果尝试在takes_ownership(s); 语句执行之后 打印s值 就会产生报错 因为s作为参数传递给takes_ownership函数 String类型 不是基本类型 不会自动拷贝, 所以String的所有权转移到函数内, 又转移给了println宏当中 但函数执行完成, String开辟的这块内存已经被释放了 所以在函数之后打印s 就会报错 ,但是如果makes_copy(x) 函数之后执行打印x 就不会报错的, 因为i32类型是基本类型, 存储在栈内会进行自动拷贝, 不会触发所有权机制 , 但如果不是存储在栈的数据 就需要将数据返回出来, 这样数据传来传去 很是麻烦, Rust就帮我们解决了这个问题 引入了借用机制。

借用

在Rust中借用 在变量前加& 就变成了借用 不会产生所有权的转移, 在其他语言我们称这样的变量是引用, 但是Rust解释器中明确表明 就称其为借用, Rust通过借用Borrow概念达成减少所有权传递程序复杂的目的: **获取变量的引用, 称之为借用 **, 可以很好的理解, 我们上学忘记带铅笔, 可以跟朋友同学去借, 但是在使用完成后, 要物归原主.这里排除老赖等极端情况...

引用与解引用

常规的引用是一个指针类型, 指向了对象存储的内存地址。 在下面我们创建一个x i32值的引用 y, 然后使用解引用得到内存中真实的数据

let x: i32 = 5;
let y = &x

assert_eq!(5, x)
assert_eq!(5, *y) // y 是 5这个i32类型的数据内存地址  *y就是反引用得到的就是内存中的真实的数据5

当然这个时候 x 和 y也都可以正常打印出来因为引用不会涉及到所有权转移的问题 x 的不会出现失效的情况

不可变引用

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

    let len = calculate_length(&s1); // 将s1的引用传递给函数

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

// 函数接受 String的引用 返回一个 usize类型  usize就是无符号的根据操作系统位数生成的整数类型 例如我们操作系统是64位 那就是u64 
fn calculate_length(s: &String) -> usize { 
    s.len()
}// 因为传入的是引用类型  所以函数执行完成后不会释放drop掉s 什么也不会发生, 通过下面看一下类型引用的整体结构

s            s1         

ptr    ->    ptr     ->   0  h
             len          1  e 
             cap          2  l
       										3  l
													4  o

上述场景我们函数传参的简易性有了, 我们不觉的想到如果想修改 数据的值可以吗, 接下来我们看下面的代码:

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

    calculate_length(&s1); // 将s1的引用传递给函数

}
 
fn calculate_length(s: &String) { 
    s.push_str(" world!"); // 再此处修改数据
}

push_str处就会报错。因为在rust中定义的引用 都是不可以更改原来的数据的 就好像我们去图书馆借书 看可以 但是如果在毁坏书籍 乱涂乱画是不被允许的, 那如何我想画就画呢? Rust 也帮我们解决了, 那就是定义引用的时候声明他是一个可变引用

可变引用

fn main() {
    let mut s1 = String::from("hello"); // 声明s1为可变参数

    calculate_length(&mut s1); // 将s1的引用传递给函数

}
 
fn calculate_length(s: &mut String) {  // 声明传递的参数必须是一个可变的String类型参数
    s.push_str(" world!"); // 再此处修改数据
}

这段代码就可以完美的运行了

但是可变引用必须遵从Rust的一个原则:可变引用同时只能存在一个, 也就是在同一个作用域中, 一个数据只能有一个可变的引用, 同时不可变可以拥有多个

也就是说 一本书我借给多个人 , 你们一堆人可以一起看, 其中只能有一个人可以对这本书 修改 , 这样的好处就是 Rust在编译时就避免了数据的竞争, 下面这段代码就出现了多引用:

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

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

	println!("{}, {}", r1, r2);
} 
// 这段代码就会报错  因为声明了两个可变引用 且他们在同一个作用域main函数中,第一个可变引用r1声明周期必须持续到print完成后 在r1的声明周期内又尝试创建了一个可变引用r2 引起了数据的竞争 




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

	let r1 = &s;
  println!("{}", r1); 
	let r2 = &mut s;   // 如果想要 一段代码中同时引用可变引用和不可变引用  他们的生命周期必须没有交集
	println!("{},", r2);  
} 

// 可变引用和不可变引用在新版本的编译器中是可以同时存在的, 1.31之前不可以
// 对于这种编译器的优化Rust专门去了一个名字NLL - Non-Lexical Lifetimes(NLL)，, 就是专门找出某一个引用在作用域 } 结束之前就不在被使用的引用的位置

悬垂引用 (出现悬空指针、 也可称迷途指针 、 野指针)

悬空指针 就是 指针指向实际的数据, 但是这个值在使用之前之前就已经被释放掉了, 但是 指针 也就是引用存在, 释放掉的内存可能不存在任何值, 或者被其他程序变新使用了, 造成了数据污染 , 而Rust编译器可以永远保证 引用不悬垂。

发生悬垂的场景:

fn main() {
    let mut testStr = String::from("testing"); 
    let result = overhang(testStr); // 将String数据传给overhang函数 此时String的所有权转移到overhang函数当中
    println!("{}",result); // 悬空指针产生了因为引用真正数据已经被释放了 找不到原本你的数据了
}

fn overhang(mut s: String) -> &String {  // 
    s.push_str("123");  // 修改String
    &s  // 返回String 的引用
} // 在此处 s 离开当前作用域 s 被drop掉 内存释放 , 返回&s 危险

error : error[E0106]: missing lifetime specifier

这里出现了关于生命周期的概念: 程序中每一个变量都有对应的作用域, 当超出作用域之后变量就会被自动销毁 一句话说就是一个变量在创建 到 被释放的过程, 称之为生命周期.

不过即使不了解生命周期仅仅了解引用 就可以理解悬垂指针。

解决上述代码的方法：将String返回 而不是&String

fn overhang(mut s: String) -> &String {  // 
    s.push_str("123");  // 修改String
    s  // 返回String 的引用
} 

这样就没有任何问题了

本文部分参照： Rust圣经