为什么要学一学 Rust？( 二 ) _Rust

上面这里有点绕，但是只要记?。?quot;可变不共享，共享不可变，结束前要还" 这句就行了。下面看 2 个例子：
可变不共享，共享不可变
fnmAIn{
letmutx = 5;
lety = &x; // y 从 x 借用一个不可变引用
letz = &mutx; // y 从 x 借用一个可变借用。报错，不能在一个作用域内同时出现可变借用和不可变借用
}
结束前要还
fnmain{
letmutx = 5; // x 是可变的，拥有值 5
lety = &mutx; // y 从 x 借用到一个可变引用
*y += 1; // 通过 y 来增加 x 的值，因为 y 是对 x 的可变引用
println!("x is {}", x); // 打印出了 6
} // y 超出了作用域，结束对 x 的引用
无畏并发
Rust 为并发代码提供了内置支持，这允许 Rust 程序充分利用多核。由于 Rust 的所有权和类型系统，在 Rust 中不可能在编译时出现数据竞争，这就是所谓的“无畏并发” 。
多线程usestd::thread;
fnmain{
thread::spawn(|| {
println!("Hello new thread!");
});
}
这会从新的线程里打印“Hello new thread!”，它是和主线程并行的。
线程通信
通道可以让消息在线程之间进行传递
usestd::thread;
usecrossbeam::channel;
fnmain{
let(tx, rx) = channel::unbounded;
thread::spawn(move|| {
tx.send("Hello from thread!").unwrap;
});
letmsg = rx.recv.unwrap;
println!("Got message: {}", msg); // Got message: Hello from thread!
}
这里我们创建了一个不限制大小的通道并生成一个新的线程，该线程在通道上发送消息，在主线程中接收消息并打印它。
共享状态
虽然通道对于消息传递很有用，但有时线程需要访问共享的状态。这可以通过互斥锁来锁定对临界区的访问，这个程序生成 10 个线程，每个线程增加一个共享计数器。通过使用互斥锁，可以确保一次只有一个线程可以访问计数器增加的临界区。
usestd::{
sync::{Arc, Mutex},
thread,
};
fnmain{
letcounter = Arc::new(Mutex::new(0));
letcounters = vec![counter.clone; 10];
forcounter in&counters {
letcounter = counter.clone;
thread::spawn(move|| {
letmutnum = counter.lock.unwrap;
*num += 1;
});
}
forcounter in&counters {
letnum = counter.lock.unwrap;
println!("{}", *num);
}
}
在 C/C++ 中实现并发可要小心翼翼，一不小心就出内存问题了。
完善的工具链
Rust 有一套很好用的工具生态，比 C/C++ 的都要完善，比如：

Cargo：类似于 NPM 的 Rust 包管理器和构建工具
Rustup：有点类似于 nvm，用来管理 Rust 版本(稳定版，测试版，夜间版) 。
Rustfmt：类似于 Prettier，代码风格格式化
Clippy：类似于 ESLint，Rust 的静态代码分析工具

总结Rust 是一种现代编程语言，它提供了速度、安全性和并发性。Rust 通过零成本抽象、移动语义、保证内存安全以及最小的运行时实现了与 C 和 C++相当的性能。Rust 编译器严格执行关于所有权、借用和生命周期的规则，可以防止各种错误如悬空指针、使用后释放错误和数据竞争等问题。此外，Rust 还对并发性和并行性有很好的支持，编译器会在编译时防止数据竞争，这可以让你写并发代码时更加从心。
我是一个搞前端的，也在学 Rust 。不管怎样，通过学 Rust 还是能够获得比前端这个领域里更多的东西，学一学总没错，实在不行你来了解一下也行嘛。