浅析Rust多线程中如何安全的使用变量

本文主要是介绍浅析Rust多线程中如何安全的使用变量，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《浅析Rust多线程中如何安全的使用变量》这篇文章主要为大家详细介绍了Rust如何在线程的闭包中安全的使用变量,包括共享变量和修改变量,文中的示例代码讲解详细,有需要的小伙伴可以参考下...

1. 向线程传递变量

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

use std::thread;

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

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

    handle.join().unwrap();
}

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

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

浅析Rust多线程中如何安全的使用变量

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

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

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

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

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

这样就可以正常运行了。

浅析Rust多线程中如何安全的使用变量

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

2. 多线程共享变量引用

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

use std::thread;

fn main() {
    let China编程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);
}

很遗憾，依然有错误：

浅析Rust多线程中如何安全的使用变量

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

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

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

总的来说就是：

移动引用并不移动原始数据-只转移引用本身的所有权
实际数据（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修改之后，变量不仅可以在多个线程中共享，主线程中也可以使用。

浅析Rust多线程中如何安全的使用变量

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);
}

在这个示例中：