Rust 所有权规则
一个值只能被一个变量所拥有，这个变量被称为所有者。
一个值同一时刻只能有一个所有者，也就是说不能有两个变量拥有相同的值。所以对应变量赋值、参数传递、函数返回等行为，旧的所有者会把值的所有权转移给新的所有者，以便保证单一所有者的约束。
当所有者离开作用域，其拥有的值被丢弃，内存得到释放。
这三条规则很好理解，核心就是保证单一所有权。其中第二条规则讲的所有权转移是 Move 语义，Rust 从 C++ 那里学习和借鉴了这个概念。
第三条规则中的作用域（scope）指一个代码块（block），在 Rust 中，一对花括号括起来的代码区就是一个作用域。举个例子，如果一个变量被定义在 if {} 内，那么 if 语句结束，这个变量的作用域就结束了，其值会被丢弃；同样的，函数里定义的变量，在离开函数时会被丢弃。
所有权规则，解决了谁真正拥有数据的生杀大权问题，让堆上数据的多重引用不复存在，这是它最大的优势。 但是，它也有一个缺点，就是每次赋值、参数传递、函数返回等行为，都会导致旧的所有者把值的所有权转移给新的所有者，这会导致一些性能上的问题。
Move关键字
Rust 是一门以安全性著称的系统编程语言，它允许程序员高效地进行并发编程。在 Rust 中，线程是一种重要的并发原语，通过标准库提供的 std::thread 模块，我们可以轻松地创建和管理线程。而 Move 闭包是一种特殊的闭包，它可以在创建时传递外部变量的所有权，使得在多线程环境中传递数据更加灵活和高效。
Rust 中的线程
在 Rust 中，线程是一种独立的执行流，它允许程序在不同的执行路径上同时运行。Rust 的线程模型采用了“共享状态，可变状态”（Shared State, Mutable State）的方式，这意味着多个线程可以访问同一个数据，但需要通过锁（Lock）来保证数据的安全性。
创建线程：在 Rust 中，我们可以使用 std::thread::spawn 函数来创建一个新的线程。下面是一个简单的例子：
use std::thread;
fn main() {
let handle = thread::spawn(|| {
println!("Hello from the new thread!");
});
handle.join().unwrap();
}
在上述示例中，我们调用 thread::spawn 函数创建了一个新的线程，并在该线程中打印一条信息。注意，thread::spawn 函数接受一个闭包作为参数，闭包中的代码会在新线程中执行。
线程间通信
在多线程编程中，线程间通信是一个重要的问题。在 Rust 中，我们可以使用 std::sync 模块提供的同步原语来实现线程间的安全通信。常见的同步原语包括 Mutex（互斥锁）和 Arc（原子引用计数）等。
下面是一个使用 Mutex 实现线程安全计数的例子：
use std::sync::{Arc, Mutex};
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());
}
在上述示例中，我们创建了一个 Mutex 来包装计数器变量 counter，以实现线程安全的计数。在每个线程中，我们通过 counter.lock().unwrap() 获取 Mutex 的锁，然后通过 *num += 1 修改计数器的值。在修改完成后，锁会自动释放。
Move 闭包
Rust 中的闭包有三种形式：Fn、FnMut 和 FnOnce。其中，FnOnce 是最特殊的一种，它可以消耗捕获的变量，并且只能被调用一次。这种特性使得 FnOnce 闭包可以在创建时携带外部变量的所有权，并在闭包内使用这些变量。
在线程中使用 Move 闭包：
在多线程编程中，有时我们希望在线程创建时将一些数据传递给新线程，并且希望新线程拥有这些数据的所有权，这时就可以使用 Move 闭包。
下面是一个使用 Move 闭包的例子：
use std::thread;
fn main() {
let data = vec![1, 2, 3, 4, 5];
let handle = thread::spawn(move || {
for num in data {
println!("Number: {}", num);
}
});
handle.join().unwrap();
}
在上述示例中，我们创建了一个 data 向量，并在 thread::spawn 函数中使用 move 关键字将 data 向量的所有权转移给了新线程。这样，新线程就拥有了 data 向量的所有权，可以在闭包中访问和使用它。
需要注意的是，使用 Move 闭包时要特别小心数据的所有权转移。如果在闭包外部继续使用了数据，可能会导致编译错误或运行时错误：
使用 Arc 和 Move 闭包
在某些情况下，我们希望在多个线程中共享数据，并且某些线程需要拥有数据的所有权。这时，可以结合使用 Arc 和 Move 闭包来实现。
下面是一个使用 Arc 和 Move 闭包的例子：
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let data = Arc::new(Mutex::new(vec![1, 2, 3, 4, 5]));
let handles: Vec<_> = (0..5)
.map(|i| {
let data = Arc::clone(&data);
thread::spawn(move || {
let mut data = data.lock().unwrap();
data[i] += 1;
})
})
.collect();
for handle in handles {
handle.join().unwrap();
}
println!("Result: {:?}", *data.lock().unwrap());
}
在上述示例中，我们创建了一个 data 向量，并将它包装在 Arc 和 Mutex 中以实现线程安全共享。然后，我们使用 map 方法创建了5个线程，并在每个线程中修改 data 向量的一个元素。通过使用 Move 闭包和 Arc，每个线程都拥有了 data 向量的所有权，可以在闭包中修改它。
多线程与 Move 闭包的应用场景
多线程和 Move 闭包在 Rust 中有着广泛的应用场景，尤其是在并发处理和性能优化方面。以下是一些常见的应用场景：
并行计算：多线程可以同时执行独立的任务，提高计算速度和性能。
并发服务器：服务器需要同时处理多个客户端请求，多线程可以使服务器更高效地处理并发请求。
数据处理：在数据处理任务中，多线程可以同时处理不同的数据块，加速数据处理过程。
