初识 Rust 语言的全部权概念

目前仅看了第二版的官方文档，记录一下初步印象，应该还有更深入一致的解释，水平有限，仅供参考。
实验环境：ubuntu17.10，rust1.18，vscode1.14 + 扩展rust（rls）。
BTW，环境搭建顺利得使人意外，Rust工具链打造的简洁精美，原生支持git，安装只需一条命令：curl https://sh.rustup.rs -sSf | sh。

初步印象

数据竞争主要有三个条件：

1. 两个或更多指针同时访问同⼀数据。
2. ⾄少有⼀个指针被写⼊。
3. 没有同步数据访问的机制。

Rust很是重视并发，根据官方介绍：Rust 是一门着眼于安全、速度和并发的编程语言。而并发须要解决的就是数据竞争问题，天然会很是重视数据的使用过程，说是当心翼翼不为过。由于数据要关联到有名变量才能使用，因此rust在语言层面上针对变量的使用引入了解决方法，主要涉及的语法有：

1. 变量定义时，不可变（immutable，默认）、可变（mutable）
2. 变量赋值时，全部权转移（move）、借用（borrow）

须要注意的是，全部权仅针对复杂类型变量（在语法上，是没有copy trait的类型），例如String、vect等在堆上存储数据的类型，而简单类型并不用考虑，如int、tuple、array等，缘由就在于赋值时数据是如何拷贝的（虽然都是浅拷贝）。

若是熟悉浅拷贝、深拷贝的概念，天然了解，对于在堆上分配空间的复杂类型，浅拷贝会致使两个或更多变量/指针同时指向同⼀数据，如有变量/指针做写入操做，就会引发数据竞争问题。

因此，Rust用可变/不可变、全部权、生命期等来破坏数据竞争的条件，而这些解决方案所有在编译期搞定！
固然，代价是难以快速验证想法，毕竟使用变量时要仔细了，不然编都编不过，期待最佳实践和IDE的支持。

基本概念

1. 不可变、可变

let x = 3;  // x 默认不可变
x = 4;  // 错误！
let x = 4;  // 正确！遮盖了原有的同名变量
let mut y = 3;  // y可变
y = 4;  // 正确！

2. 全部权转移（move）

fn test(v: String) { println!("fn: {}", v); }  // 函数
let x = String::from("hello");  // 全部者x（String类型）
let y = x;  // 数据的全部权转移给y！
let z = x; // 错误！x已不可用
test(y);  // 全部权转移，新的全部者是形参v！当函数执行完毕，v离开做用域时值被丢弃（drop）！
println!("var: {}", y);  // 错误！y已不可用

这不免有使人抓狂的感受，还能不能愉快地玩耍了？这数据跑得跟兔子同样，想用的时候都不知道去哪了！还可能无心中跑到函数里直接躺尸！

3. 借用/引用（borrow）

那么，一个变量想屡次使用怎么办？答案是能够借用**：使⽤其值但不获取其全部权**。

fn test1(v: String) { println!("fn: {}", v); } 
fn test2(v: &String) { println!("fn: {}", v); }  // 参数为引用类型
let s = String::from("hello");  // 全部者s（String类型）
let s1 = &s;  // 不可变借用（borrow）！
let s2 = &s;  // 借用
let s3 = s1;  // 借用
test2(s1);  // 借用
test1(*s1);  // 错误！借用者s1没有全部权，没法经过s1转移（cannot move out of borrowed content）。
println!("var: {}", s); // 正确

**小结：**我的感受，全部权转移主要为并发服务，自己并不经常使用，毕竟数据常常要复用，没人乐意要一直提防着数据跑哪去了，尤为在函数调用时。既然如此，通常把全部者保持不变，多使用引用，主要体如今复杂数据结构和函数上。

进一步

可是，实际使用的状况会比较复杂，即是否可变与转移、借用三者相互影响（混用）的状况。
从数据竞争的角度：读读不冲突，但读写、写写会冲突（读即不可变，写便可变）；从实现的角度：引用是基于全部权的。
所以，能够看看哪些对象会冲突：(全部者，引用) × (不可变，可变)

• 首先，是否可变和全部权没有关系。

let x = String::from("hello");
let mut z = x;  // 转移后变量x不可用
z.push_str(" z");  //正确
// 可变引用要用星号来得到引用的内容，不可变引用不须要。
let mut x = 5; 
let y = &mut x;
*y += 1;

• 虽然不可变引用（&T）没有全部权，不会致使值被误转移，但借用之时要求值不能变，这意味着此时：全部权不能转移、全部者不能改值、不能同时有可变引用！

let mut x = String::from("hello");
let y = &x;  // 不可变引用
let z = x;  // 错误
x.push_str(" x");  // 错误
let z = &mut x;  // 错误：可变引用

可变引用（&mut T）

可变引用使用上略复杂，概念上也没有太统一的理解，这里单独考查。
“可变权”便可变引用对数据的读写权，具备惟一性（只有一个可用的可变引用）和独占性（其它读、写通通无效），因此对编译影响至关大。可变引用的可变权和全部者对数据的全部权有类似性，由于可变权也有move行为。

**注：**官方文档里没有可变权的概念，但我的感受，用这个概念比较好理解可变引用的使用，也许还有更本质的解释，仅供参考。

• 可变权move的两种方式

let mut x = String::from("hello");  // 全部者x有可变权
 // 1. 直接转移
let y = &mut x;  // 1. y为可变引用，可变权move自x
let z = y;  // 直接转移。z为可变引用
y.push_str(" y");  // 错误！y的可变权已move给z
z.push_str(" z");  // 正确
 // 2. 间接转移
let mut y = &mut x;  // 2. y为可变引用，可变权move自x
let w = &mut y;  // 要求y可变。w为可变引用
w.push_str(" w");  // 正确
// 转移（函数）
fn test(i: &mut String) { 
	i.push_str(" i");   // 正确
}
let mut x = String::from("hello");  // 全部者x有可变权
test(&mut x);
x.push_str(" x");  // 正确！可变权已归还

• 可变引用如有写入操做则要求全部者可变。

let x = String::from("hello");  // x不可变
let mut z = &x;   // z为不可变引用
z.push_str(" z");  // 错误！
let w = &mut z;  // w为可变引用
w.push_str(" w");  // 错误！
let mut y = x;  // 全部权转移，y可变
let z = &mut y;   // z为可变引用，要求y可变
z.push_str(" z");  // 正确！
let w = &z;  // w 为不可变引用
w.push_str(" w");  // 错误！

总结：

由于都涉及到值的修改，可变引用的行为和全部者类似，并且可变权和全部权都是面向数据且惟一的。

全部者

1. 有全部权，move后再也不可用，当全部者生命期结束，值被丢弃。
2. 读的时候相似不可变引用，写的时候相似可变引用。

可变引用（&mut T）

1. 有可变权，move自被引用者，当可变引用生命期结束，可变权自动归还。
2. 可变权的源头应该来自全部者，不然意义不大。

参考

1. Rust 环境配置事项一览
2. 官方文档：Rust 程序设计语言（第二版）
3. Rust教程11之全部权
4. 你在开发过程当中都遇到过 Rust 的哪些坑？