阿里妹导读：我们在选择一种开发语言时会综合考量各方面的特性，根据实际的需求适当取舍。鱼和熊掌往往不可兼得，要想开发效率高，必然要牺牲性能和资源消耗，反之亦然。但是Rust却出其不意，令人眼前一亮！本文将从性能、内存安全、开发效率、跨平台性及生态等五个方面，对Rust这一编程语言进行一些科普性质的分享。
| rust | c++ | golang | python |
| 249KB | 129KB | 1577KB | 3880KB |
结论：（二进制大小）python > golang > rust > c++
| rust | c++ | golang | python | |
| 第一次 | 850 | 776 | 378 | 30 |
| 第二次 | 859 | 782 | 797 | 30 |
| 第三次 | 857 | 777 | 391 | 30 |
| 第四次 | 827 | 740 | 684 | 31 |
结论：（运行效率）rust > c++ > golang > python
| rust | c++ | golang | python |
| 30M | 22M | 124M | 190M |
结论：（内存消耗） python > golang > rust > c++
| rust | c++ | golang | python |
| 12.5% | 12.5% | 24 | 13 |
结论：（CPU消耗）golang > python > rust = c++
let obj = String::from("hello");fn main() {let s = String::from("hello");let s1 = s; //所有权发生了转移，由s转移给s1print!("{}",s); //s无效，不能访问，此句编译会报错}
fn test(s1:String){print!("{}",s1);}fn main() {let s = String::from("hello");test(s); //传参，所有权发生了转移print!("{}",s); //此处s无效，编译报错}
fn test(s1:&String){print!("{}",s1);}fn main() {let s = String::from("hello");test(&s); //传参，注意只是传递了引用，所有权还归属于sprint!("{}",s); //此处s依然有效，可以访问}
fn main() {let s = String::from("hello");let s1 = &s; //s1借用s，所有权还归属于sprint!("{}",s); //此处s依然有效，可以访问print!("{}",s1); //此处s1和s指向同一个对象}
fn main() {let s = String::from("hello");change(&s);}fn change(some_string: &String) {some_string.push_str(", world");}
error[E0596]: cannot borrow immutable borrowed content `*some_string` as mutable--> error.rs:8:5|7 | fn change(some_string: &String) {| ------- use `&mut String` here to make mutable8 | some_string.push_str(", world");| ^^^^^^^^^^^ cannot borrow as mutable
fn main() {let mut s = String::from("hello");change(&mut s);}fn change(some_string: &mut String) {some_string.push_str(", world");}
let mut s = String::from("hello");let r1 = &mut s;let r2 = &mut s;
error[E0499]: cannot borrow `s` as mutable more than once at a time--> borrow_twice.rs:5:19|4 | let r1 = &mut s;| - first mutable borrow occurs here5 | let r2 = &mut s;| ^ second mutable borrow occurs here6 | }| - first borrow ends here
fn main() {let reference_to_nothing = dangle();}fn dangle() -> &String {let s = String::from("hello");&s}
error[E0106]: missing lifetime specifier--> dangle.rs:5:16|5 | fn dangle() -> &String {| ^ expected lifetime parameter|= help: this function's return type contains a borrowed value, but there isno value for it to be borrowed from= help: consider giving it a 'static lifetime
一个可变引用。
任意数量的不可变引用。
error[E0106]: missing lifetime specifier--> dangle.rs:5:16|5 | fn dangle() -> &String {| ^ expected lifetime parameter|= help: this function's return type contains a borrowed value, but there isno value for it to be borrowed from= help: consider giving it a 'static lifetime
error: `x` does not live long enough|6 | r = &x;| - borrow occurs here7 | }| ^ `x` dropped here while still borrowed...10 | }| - borrowed value needs to live until here
{let r; // -------+-- 'a// |{ // |let x = 5; // -+-----+-- 'br = &x; // | |} // -+ |// |println!("r: {}", r); // |} // -------+
两个或更多指针同时访问同一数据。
至少有一个这样的指针被用来写入数据。
不存在同步数据访问的机制。
use std::thread;fn main() {let v = vec![1, 2, 3];let handle = thread::spawn(|| {println!("Here's a vector: {:?}", v);});handle.join().unwrap();}
error[E0373]: closure may outlive the current function, but it borrows `v`,which is owned by the current function--> src/main.rs:6:32|6 | let handle = thread::spawn(|| {| ^^ may outlive borrowed value `v`7 | println!("Here's a vector: {:?}", v);| - `v` is borrowed here|help: to force the closure to take ownership of `v` (and any other referencedvariables), use the `move` keyword|6 | let handle = thread::spawn(move || {| ^^^^^^^
use std::thread;fn main() {let v = vec![1, 2, 3];let handle = thread::spawn(|| {println!("Here's a vector: {:?}", v);});drop(v); // 强制释放变量vhandle.join().unwrap();}
help: to force the closure to take ownership of `v` (and any other referencedvariables), use the `move` keyword|6 | let handle = thread::spawn(move || {
use std::thread;fn main() {let v = vec![1, 2, 3];let handle = thread::spawn(move || { //使用 move 关键字强制获取它使用的值的所有权，接下来就可以正常使用v了println!("Here's a vector: {:?}", v);});handle.join().unwrap();}
use std::thread;use std::sync::mpsc;fn main() {let (tx, rx) = mpsc::channel();thread::spawn(move || {let val = String::from("hi");tx.send(val).unwrap();});let received = rx.recv().unwrap();println!("Got: {}", received);}
use std::thread;use std::sync::mpsc;fn main() {let (tx, rx) = mpsc::channel();thread::spawn(move || {let val = String::from("hi");tx.send(val).unwrap();println!("val is {}", val);//在这里会发生编译错误});let received = rx.recv().unwrap();println!("Got: {}", received);}
error[E0382]: use of moved value: `val`--> src/main.rs:10:31|9 | tx.send(val).unwrap();| --- value moved here10 | println!("val is {}", val);| ^^^ value used here after move|= note: move occurs because `val` has type `std::string::String`, which doesnot implement the `Copy` trait
use std::sync::Mutex;use std::thread;fn main() {let counter = Mutex::new(0);let mut handles = vec![];for _ in 0..10 {let handle = thread::spawn(move || {let mut num = counter.lock().unwrap();*num += 1;});handles.push(handle);}for handle in handles {handle.join().unwrap();}println!("Result: {}", *counter.lock().unwrap());}
error[E0382]: capture of moved value: `counter`--> src/main.rs:10:27|9 | let handle = thread::spawn(move || {| ------- value moved (into closure) here10 | let mut num = counter.lock().unwrap();| ^^^^^^^ value captured here after move|= note: move occurs because `counter` has type `std::sync::Mutex<i32>`,which does not implement the `Copy` traiterror[E0382]: use of moved value: `counter`--> src/main.rs:21:29|9 | let handle = thread::spawn(move || {| ------- value moved (into closure) here...21 | println!("Result: {}", *counter.lock().unwrap());| ^^^^^^^ value used here after move|= note: move occurs because `counter` has type `std::sync::Mutex<i32>`,which does not implement the `Copy` traiterror: aborting due to 2 previous errors
let handle = thread::spawn(move || {let mut num = counter.lock().unwrap();*num += 1;});handles.push(handle);let handle2 = thread::spawn(move || {let mut num2 = counter.lock().unwrap();*num2 += 1;});handles.push(handle2);
error[E0382]: capture of moved value: `counter`--> src/main.rs:16:24|8 | let handle = thread::spawn(move || {| ------- value moved (into closure) here...16 | let mut num2 = counter.lock().unwrap();| ^^^^^^^ value captured here after move|= note: move occurs because `counter` has type `std::sync::Mutex<i32>`,which does not implement the `Copy` traiterror[E0382]: use of moved value: `counter`--> src/main.rs:26:29|8 | let handle = thread::spawn(move || {| ------- value moved (into closure) here...26 | println!("Result: {}", *counter.lock().unwrap());| ^^^^^^^ value used here after move|= note: move occurs because `counter` has type `std::sync::Mutex<i32>`,which does not implement the `Copy` traiterror: aborting due to 2 previous errors
use std::rc::Rc;use std::sync::Mutex;use std::thread;fn main() {let counter = Rc::new(Mutex::new(0));let mut handles = vec![];for _ in 0..10 {let counter = Rc::clone(&counter);let handle = thread::spawn(move || {let mut num = counter.lock().unwrap();*num += 1;});handles.push(handle);}for handle in handles {handle.join().unwrap();}println!("Result: {}", *counter.lock().unwrap());}
error[E0277]: the trait bound `std::rc::Rc<std::sync::Mutex<i32>>:std::marker::Send` is not satisfied in `[closure@src/main.rs:11:36:15:10counter:std::rc::Rc<std::sync::Mutex<i32>>]`--> src/main.rs:11:22|11 | let handle = thread::spawn(move || {| ^^^^^^^^^^^^^ `std::rc::Rc<std::sync::Mutex<i32>>`cannot be sent between threads safely|= help: within `[closure@src/main.rs:11:36: 15:10counter:std::rc::Rc<std::sync::Mutex<i32>>]`, the trait `std::marker::Send` isnot implemented for `std::rc::Rc<std::sync::Mutex<i32>>`= note: required because it appears within the type`[closure@src/main.rs:11:36: 15:10counter:std::rc::Rc<std::sync::Mutex<i32>>]`= note: required by `std::thread::spawn`
use std::sync::{Mutex, Arc};use std::thread;fn main() {let counter = Arc::new(Mutex::new(0));let mut handles = vec![];for _ in 0..10 {let counter = Arc::clone(&counter);let handle = thread::spawn(move || {let mut num = counter.lock().unwrap();*num += 1;});handles.push(handle);}for handle in handles {handle.join().unwrap();}println!("Result: {}", *counter.lock().unwrap());}
相关链接 [1]https://github.com/famzah/langs-performance [2]https://benchmarksgameteam.pages.debian.net/benchmarksgame/fastest/rust-gpp.html [3]https://deavid.wordpress.com/2019/10/12/benchmarking-python-vs-pypy-vs-go-vs-rust/ [4]https://www.chromium.org/Home/chromium-security/memory-safetyhttps://www.zdnet.com/article/microsoft-70-percent-of-all-security-bugs-are-memory-safety-issues/ [5]https://www.bookstack.cn/read/trpl-zh-cn/src-ch10-03-lifetime-syntax.md [6]https://github.com/redox-os/redox [7]https://stackoverflow.blog/2020/06/05/why-the-developers-who-use-rust-love-it-so-much/ [8]https://blog.discord.com/why-discord-is-switching-from-go-to-rust-a190bbca2b1f
