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

use std::thread;

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

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

    handle.join().unwrap();
}

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

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

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