Rust多线程中安全的使用变量

在Rust语言中，一个既引人入胜又可能带来挑战的特性是闭包如何从其所在环境中捕获变量，尤其是在涉及多线程编程的情境下。

如果尝试在不使用move关键字的情况下创建新线程并传递数据至闭包内，编译器将很可能返回一系列与生命周期、借用规则及所有权相关的复杂错误信息。

不过，这种机制虽然增加了学习曲线，但也确保了内存安全与并发执行中的数据一致性。

本文我们将探讨如何在线程的闭包中安全的使用变量，包括共享变量和修改变量。

1. 向线程传递变量

首先，我们构造一个简单的示例，在线程中正常使用一个外部的变量，看看Rust中能否正常编译运行。

use std::thread;

fn main() {
    let msg = String::from("Hello World!");

    let handle = thread::spawn(|| {
        // msg 是主线中定义的变量
        println!("{}", msg);
    });

    handle.join().unwrap();
}

例子非常简单，看着写法也没什么问题，在其他编程语言中类似的写法是没有问题的。

但是，使用cargo run运行时，却有如下的错误：

为什么会有这样的错误？这就是Rust在内存方面更加严谨的原因。

上面Rust的错误信息中也给出了原因，总结起来主要有两点：

1. 线程的生命周期：新创建的线程的生命周期有可能超出主函数 main 的执行范围。当 main 函数终止时，与之相关的局部变量（也就是msg）将超出作用域。
2. 不符合借用规则：在 Rust 中，引用的生命周期不会超过其所指向数据的生命周期，以避免出现悬空引用。如果main提前结束，那么线程中的msg将成为悬空引用。

修复的方法很简单，使用move关键字，将变量的所有权转移到线程中就可以了。

    let handle = thread::spawn(move || {
        // msg 是主线中定义的变量
        println!("{}", msg);
    });

这样就可以正常运行了。

不过，这样，主线程中就无法使用变量msg了，比如在main函数的最后打印msg，会报错，因为它的所有权已经转移到线程中了。

2. 多线程共享变量引用

如果我们只把变量的引用转移给线程，是不是可以在主线程main中继续使用变量msg呢？

use std::thread;

fn main() {
    let msg = String::from("Hello World!");
    let msg_ref = &msg;

    let handle = {

        thread::spawn(move || {
            // msg 是主线中定义的变量
            println!("{}", msg_ref);
        })
    };

    handle.join().unwrap();

    println!("msg in main : {}", msg_ref);
}

很遗憾，依然有错误：

错误的原因仍然是传入线程中的变量引用msg_ref生命周期的不够长。

虽然我们使用了move，将msg_ref转移到线程中，但main中仍然拥有底层的数据msg，

一旦main函数结束（或者数据在线程完成之前超出范围），该引用（msg_ref）指向数据将失去有效的内存，成为悬空引用。

总的来说就是：

1. 移动引用并不移动原始数据-只转移引用本身的所有权
2. 实际数据（msg）仍然由原始范围拥有，并具有自己的生命周期约束

为了修复这个错误，就要用到Rust中提供的并发原语Arc（一种自动引用计数的智能指针）。

先看看使用Arc修改后的例子。

use std::sync::Arc;
use std::thread;

fn main() {
    let msg = String::from("Hello World!");
    // 通过Arc来创建变量的引用
    let msg_ref = Arc::new(msg);

    // 线程1
    let handle_1 = {
        // move 之前，先使用Arc clone 变量
        let msg_thread = Arc::clone(&msg_ref);

        thread::spawn(move || {
            println!("Thread 1: {}", msg_thread);
        })
    };

    // 线程2
    let handle_2 = {
        let msg_thread = Arc::clone(&msg_ref);

        thread::spawn(move || {
            println!("Thread 2: {}", msg_thread);
        })
    };

    handle_1.join().unwrap();
    handle_2.join().unwrap();

    // 主线程中依然可以使用变量
    println!("msg in main : {}", msg_ref);
}

使用Arc修改之后，变量不仅可以在多个线程中共享，主线程中也可以使用。

3. 多线程中修改变量

上面的示例是在多个线程中共享变量，如果想要修改变量的话，那么就会出现数据竞争的情况。

这时，就要用到Rust的另一个并发原语Mutex。

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    // 创建一个被Mutex保护的共享数据，这里是一个i32类型的数字
    let shared_number = Arc::new(Mutex::new(0));

    // 定义一个线程向量，用于存储创建的线程
    let mut threads = Vec::new();

    // 创建10个线程，每个线程对共享数据进行1000次递增操作
    for _ in 0..10 {
        // 克隆Arc，使得每个线程都拥有一个指向共享数据的引用
        let num_clone = Arc::clone(&shared_number);
        let handle = thread::spawn(move || {
            // 尝试获取Mutex的锁，这是一个阻塞操作，如果锁不可用，线程会等待
            let mut num = num_clone.lock().unwrap();
            for _ in 0..1000 {
                *num += 1;
            }
        });
        threads.push(handle);
    }

    // 等待所有线程完成操作
    for handle in threads {
        handle.join().unwrap();
    }

    // 获取最终的共享数据值并打印
    let final_num = shared_number.lock().unwrap();
    println!("最终10个线程的累加结果: {}", final_num);
}

在这个示例中：

1. 首先创建了一个Arc<Mutex<i32>>类型的共享数据，Arc用于在多个线程间共享Mutex，Mutex用于保护内部的i32数据。
2. 循环创建10个线程，每个线程都克隆了Arc并尝试获取Mutex的锁。一旦获取到锁，线程就可以安全地对共享数据进行递增操作。
3. 主线程使用join方法等待所有子线程完成操作。
4. 最后，主线程获取并打印共享数据的最终值。由于Mutex的保护，多个线程对共享数据的操作不会产生数据竞争，保证了数据的一致性。

运行结果：

10个线程，每个累加1000，所以最后结果是1000*10=10000。

4. 总结

从上面的例子可以看出，Rust的闭包捕获规则最初可能感觉很严格，但它们在确保内存安全和数据竞争自由方面至关重要。

总之，

如果需要在另一个线程中拥有数据，考虑使用move；

如果需要跨线程共享数据，考虑使用Arc；

如果需要跨线程共享和修改数据，考虑使用Arc+Mutex；