初识Rust语言的所有权概念

简介:

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

初步印象

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

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

R非常重视并发,根据官方介绍: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. 可变权的源头应该来自所有者,否则意义不大。
作者:amita
来源:51CTO
相关文章
|
3月前
|
Rust 安全 Java
探索Rust语言的并发编程模型
探索Rust语言的并发编程模型
|
3月前
|
Rust 安全 区块链
探索Rust语言:系统编程的新选择
【10月更文挑战第27天】Rust语言以其安全性、性能和并发性在系统编程领域受到广泛关注。本文介绍了Rust的核心特性,如内存安全、高性能和强大的并发模型,以及开发技巧和实用工具,展示了Rust如何改变系统编程的面貌,并展望了其在WebAssembly、区块链和嵌入式系统等领域的未来应用。
|
3月前
|
Rust 安全 编译器
编程语言新宠:Rust语言的特性、优势与实战入门
【10月更文挑战第26天】Rust语言诞生于2006年,由Mozilla公司的Graydon Hoare发起。作为一门系统编程语言,Rust专注于安全和高性能。通过所有权系统和生命周期管理,Rust在编译期就能消除内存泄漏等问题,适用于操作系统、嵌入式系统等高可靠性场景。
225 2
|
3月前
|
Rust 安全 Java
编程语言新宠:Rust语言的特性、优势与实战入门
【10月更文挑战第27天】Rust语言以其独特的特性和优势在编程领域迅速崛起。本文介绍Rust的核心特性,如所有权系统和强大的并发处理能力,以及其性能和安全性优势。通过实战示例,如“Hello, World!”和线程编程,帮助读者快速入门Rust。
223 1
|
3月前
|
Rust 安全
深入理解Rust语言的所有权系统
深入理解Rust语言的所有权系统
95 0
|
3月前
|
Rust 安全 前端开发
探索Rust语言的异步编程模型
探索Rust语言的异步编程模型
|
3月前
|
Rust 安全 云计算
Rust语言入门:安全性与并发性的完美结合
【10月更文挑战第25天】Rust 是一种系统级编程语言,以其独特的安全性和并发性保障而著称。它提供了与 C 和 C++ 相当的性能,同时确保内存安全,避免了常见的安全问题。Rust 的所有权系统通过编译时检查保证内存安全,其零成本抽象设计使得抽象不会带来额外的性能开销。Rust 还提供了强大的并发编程工具,如线程、消息传递和原子操作,确保了数据竞争的编译时检测。这些特性使 Rust 成为编写高效、安全并发代码的理想选择。
72 0
|
6月前
|
Rust 安全 Go
揭秘Rust语言:为何它能让你在编程江湖中,既安全驰骋又高效超车,颠覆你的编程世界观!
【8月更文挑战第31天】Rust 是一门新兴的系统级编程语言,以其卓越的安全性、高性能和强大的并发能力著称。它通过独特的所有权和借用检查机制解决了内存安全问题,使开发者既能享受 C/C++ 的性能,又能避免常见的内存错误。Rust 支持零成本抽象,确保高级抽象不牺牲性能,同时提供模块化和并发编程支持,适用于系统应用、嵌入式设备及网络服务等多种场景。从简单的 “Hello World” 程序到复杂的系统开发,Rust 正逐渐成为现代软件开发的热门选择。
118 1
|
4月前
|
Rust 安全 网络安全
在 Rust 语言中,寻找企业上网行为管理软件的突破
在数字化企业环境中,上网行为管理软件对于保障网络安全和提升工作效率至关重要。Rust 语言凭借其安全性、高性能和并发性,为开发此类软件提供了新机遇。本文通过几个 Rust 代码示例,展示了如何实现网址检查、访问频率统计及访问控制等功能,旨在探索 Rust 在企业上网行为管理中的应用潜力。
65 0
|
6月前
|
Rust 安全 编译器
初探 Rust 语言与环境搭建
Rust 是一门始于2006年的系统编程语言,由Mozilla研究员Graydon Hoare发起,旨在确保内存安全而不牺牲性能。通过所有权、借用和生命周期机制,Rust避免了空指针和数据竞争等问题,简化了并发编程。相较于C/C++,Rust在编译时预防内存错误,提供类似C++的语法和更高的安全性。Rust适用于系统编程、WebAssembly、嵌入式系统和工具开发等领域。其生态系统包括Cargo包管理器和活跃社区。学习资源如"The Book"和"Rust by Example"帮助新手入门。安装Rust可通过Rustup进行,支持跨平台操作。
195 2
初探 Rust 语言与环境搭建