Rust多線程之資料共享

1. 怎麼建立線程

我們都知道Java中通過實作Runnable接口或繼承Thread類，來完成一個線程的建立，那麼在Rust中是如何實作一個線程的呢？代碼如下。

fn how_to_create_a_thread(){
	// 建立一個線程
    let thread_handle = thread::spawn(|| {
        println!("Thread inner");
    });
    // 阻塞線程，并等待其自己執行完畢
    thread_handle.join().unwrap();
}
           

在Rust中，在

std::thread

，可以直接通過

thread::spawn(||{})

方式建立出一個線程，并且傳回該線程

JoinHandle

，可以通過

JoinHandle

進行join操作。

2. 如何實作線程資料共享？

2.1 單線程

不難猜出，同Java類似，通過加鎖的方式保證其資料安全。我們來看具體實作代碼。

fn test_single_thread(){
    let m = Mutex::new(5);
    {
        let  mut num = m.lock().unwrap();
        *num = 6;
    }
    println!("m = {:?}", m);
}
           

在Rust中，通過

std::sync::Mutex

類，

Mutex::new(t: T)

，将需要共享的資料放進去即可，通過，lock()方法，對資料加鎖并擷取資料，這樣就可以對加鎖的資料進行操作。 但是與Java有所不同的是：Rust中的鎖實作了Drop接口，會自動釋放，不需要手動Unlock。用Java代碼解釋，就是類似實作了

AutoCloseable

接口，可以實作自動關閉。代碼如下：

public class Mutex implement AutoCloseable{
    public void close() throws Exception{
    }
}
try(Mutex mut = new Mutex(5)){
    
}
           

2.2 多線程

單線程實作資料共享看起來蠻簡單的，直接建立一個線程，然後運作就完了，就看不出來。那如何實作多線程呢？代碼如下：

// 多線程和鎖
fn test_mulit_thread() {
	// 使用Arc實作clone功能
    // 對Mutex::new生成的對象實作clone功能
    // 如果不實作clone，隻能移動一次
    let lock_sub = Arc::new(Mutex::new(0));

    let mut thread_list = vec![];

    for _ in 0..10 {
        // clone 鎖對象，否則下方 move一次後，其他for循環将擷取不到鎖對象
        let lock = Arc::clone(&lock_sub);
        
        let thandle = thread::spawn(move || {
            let mut num = lock.lock().unwrap();
            *num += 1
        });
        thread_list.push(thandle);
    }

    for handle in thread_list {
        handle.join().unwrap();
    }
    println!("Result  : {}", *lock_sub.lock().unwrap());
           

上方例子是标準實作多線程資料共享的方式。其實有如下疑問，可以說一下。

1. 為什麼要使用Arc對象包裝？

   Arc原名：atomically reference counted，原子引用計數。是Rc類型的原子擴充。包含clone方法，對對象進行clone。便于多線程操作同一個對象。

2. 線程中move問題

   move可以從字面意思了解，就是移動，把lock對象從一個作用域移動到了線程類。Rust對對象的所有權有嚴格控制，這個需要了解。

2.2.1 疑問

通過上面的方式實作了多線程，其實還有蠻多疑問的， 如果我就是不用Arc對象，而是采用普通對象，或者說Rc對象了，就真的不能實作多線程間的資料共享嗎？

2.2.1.1 普通對象

普通對象即：直接一個對象。 這有的方式不行，因為多線程間共享變量就必須用到多個對象，即對象的多副本，那麼就要實作Rc對象。

2.2.1.2 用Rc對象實作多資料共享

通過Rc對象，來實作多線程資料共享，代碼如下。

fn test_mulit_thread_by_rc() {

    let lock_sub = Rc::new(Mutex::new(0));

    let mut thread_list = vec![];

    for _ in 0..10 {
        let lock = Rc::clone(&lock_sub);
        
        let thandle = thread::spawn(move || {
            let mut num = lock.lock().unwrap();
            *num += 1
        });
        thread_list.push(thandle);
    }

    for handle in thread_list {
        handle.join().unwrap();
    }
    println!("Result  : {}", *lock_sub.lock().unwrap());
}
           

代碼同Arc沒什麼不同，就是把Arc對象換成Rc對象，然後試着編譯。出現如下錯誤：

45  |           let thandle = thread::spawn(move || {
    |  _______________________^^^^^^^^^^^^^_-
    | |                       |
    | |                       `std::rc::Rc<std::sync::Mutex<i32>>` cannot be sent between threads safely
           

标紅的提示：``std::rc::Rc<std::sync::Mutex>

cannot be sent between threads safely

,就是說Rc不是線程安全的。沒辦法，編譯不過去。不死心，我又換了一種寫法。代碼如下。

fn test_mulit_thread_by_rc() {
    let lock_sub = Rc::new(0);
    let mut thread_list = vec![];
    for _ in 0..10 {
        let mut lock = Rc::clone(&lock_sub);
        
        let thandle = thread::spawn(move || {
            *lock += 1
        });
        thread_list.push(thandle);
    }
    for handle in thread_list {
        handle.join().unwrap();
    }
    println!("Result  : {}", *lock_sub);
}
           

我放棄鎖了，不加鎖，能行嗎？ 通過編入後，還是出現了

``std::rc::Rc<std::sync::Mutex<i32>>

cannot be sent between threads safely`這個錯誤，看來和Mutex對象沒有關系啦。

3. 總結

本文主要講述了如何實作線程，多線程，以及線程間的資料共享問題。但是我們知道，在多線程中，多線程操作資料，會出現死鎖等問題，這個還沒有說道。以後在慢慢聊。希望本文對大家有所幫助。謝謝！

你的每一個點贊，我都當做喜歡