Rust 中的線程

在 Rust 中，線程是輕量級的執(zhí)行單元，可以并行執(zhí)行多個任務(wù)。Rust 中的線程由標準庫提供的 std::thread 模塊支持，使用線程需要在程序中引入該模塊。可以使用 std::thread::spawn() 函數(shù)創(chuàng)建一個新線程，該函數(shù)需要傳遞一個閉包作為線程的執(zhí)行體。閉包中的代碼將在新線程中執(zhí)行，從而實現(xiàn)了并發(fā)執(zhí)行。例如：

use std::thread;
fn main() {
    // 創(chuàng)建一個新線程
    let handle = thread::spawn(|| {
        // 在新線程中執(zhí)行的代碼
        println!("Hello from a new thread!");
    });
    // 等待新線程執(zhí)行完畢
    handle.join().unwrap();
    // 主線程中的代碼
    println!("Hello from the main thread!");
}

上面的代碼創(chuàng)建了一個新線程，并在新線程中打印了一條消息。在主線程中，調(diào)用了 handle.join() 方法等待新線程執(zhí)行完畢。在新線程執(zhí)行完畢后，程序會繼續(xù)執(zhí)行主線程中的代碼。

需要注意的是，Rust 的線程是“無法共享堆棧”的。也就是說，每個線程都有自己的堆棧，不能直接共享數(shù)據(jù)。如果需要在線程之間共享數(shù)據(jù)，可以使用 Rust 的線程安全原語，例如 Mutex、Arc 等。

線程作用域

在 Rust 中，std::thread::scope 是一個函數(shù)，它允許在當前作用域中創(chuàng)建一個新的線程作用域。在這個作用域中創(chuàng)建的線程將會在作用域結(jié)束時自動結(jié)束，從而避免了手動調(diào)用 join() 方法的麻煩。

std::thread::scope 函數(shù)需要傳遞一個閉包，該閉包中定義了線程的執(zhí)行體。與 std::thread::spawn 不同的是，該閉包中可以訪問其父作用域中的變量。

下面是一個簡單的例子，展示了如何使用 std::thread::scope：

use std::thread;
fn main() {
    let mut vec = vec![1, 2, 3];
    thread::scope(|s| {
        s.spawn(|_| {
            vec.push(4);
        });
    });
    println!("{:?}", vec);
}

在這個例子中，我們使用 thread::scope 創(chuàng)建了一個新的線程作用域。在這個作用域中，我們創(chuàng)建了一個新的線程，并在其中向 vec 向量中添加了一個新元素。由于線程作用域在閉包執(zhí)行完畢時自動結(jié)束，因此在 println! 語句中打印出的 vec 向量中并沒有包含新添加的元素。

需要注意的是，在使用 thread::scope 創(chuàng)建線程時，閉包的參數(shù)類型必須是 &mut std::thread::Scope，而不是 &mut 閉包中所訪問的變量的類型。這是因為 thread::scope 函數(shù)需要傳遞一個可變引用，以便在作用域結(jié)束時正確釋放線程的資源。

所有權(quán)共享

在 Rust 中，所有權(quán)共享是一種允許多個變量同時擁有同一值的所有權(quán)的方式。這種方式被稱為“所有權(quán)共享”，因為它允許多個變量共享對同一值的所有權(quán)。這是 Rust 的一項重要特性，可以幫助避免內(nèi)存泄漏和數(shù)據(jù)競爭等問題。

在 Rust 中，有三種方式可以實現(xiàn)所有權(quán)共享：靜態(tài)變量（Statics）、內(nèi)存泄漏（Leaking）和引用計數(shù)（Reference Counting）。

• 靜態(tài)變量（Statics）

靜態(tài)變量是指在程序運行期間一直存在的變量。在 Rust 中，可以使用 static 關(guān)鍵字來定義靜態(tài)變量。靜態(tài)變量在程序運行期間只會被初始化一次，且只有一個實例，所以多個變量可以共享對同一靜態(tài)變量的所有權(quán)。

以下是一個示例：

static mut COUNTER: i32 = 0;
fn main() {
    unsafe {
        COUNTER += 1;
        println!("Counter: {}", COUNTER);
    }
}

在這個例子中，我們定義了一個名為 COUNTER 的靜態(tài)變量，并使用 static mut 來表示它是一個可變的靜態(tài)變量。然后，在 main 函數(shù)中，我們通過 unsafe 代碼塊來訪問 COUNTER 變量，并將其加一。需要注意的是，在 Rust 中，訪問靜態(tài)變量是不安全的操作，所以必須使用 unsafe 代碼塊來進行訪問。

• 內(nèi)存泄漏（Leaking）

內(nèi)存泄漏是指在程序運行期間分配的內(nèi)存沒有被釋放的情況。在 Rust 中，可以使用 Box::leak 方法來實現(xiàn)內(nèi)存泄漏。Box::leak 方法會返回一個指向堆上分配的值的指針，但不會釋放這個值的內(nèi)存。這樣，多個變量就可以共享對同一堆分配的值的所有權(quán)。

以下是一個示例：

use std::mem::forget;
fn main() {
    let value = Box::new("Hello, world!".to_string());
    let pointer = Box::leak(value);
    let reference1 = &*pointer;
    let reference2 = &*pointer;
    forget(pointer);
    println!("{}", reference1);
    println!("{}", reference2);
}

在這個例子中，我們使用 Box::new 創(chuàng)建一個新的堆分配的值，并將其賦值給 value 變量。然后，我們使用 Box::leak 方法來講 value 的所有權(quán)泄漏到堆上，并返回一個指向堆上分配的值的指針。接著，我們使用 &* 來將指針解引用，并將其賦值給 reference1 和 reference2 變量。最后，我們使用 std::mem::forget 函數(shù)來避免釋放

• 引用計數(shù)

引用計數(shù)是一種在 Rust 中實現(xiàn)所有權(quán)共享的方式，它允許多個變量共享對同一值的所有權(quán)。在 Rust 中，引用計數(shù)使用 Rc<T>（“引用計數(shù)”）類型來實現(xiàn)。Rc<T> 類型允許多個變量共享對同一值的所有權(quán)，但是不能在運行時進行修改，因為 Rc<T> 類型不支持內(nèi)部可變性。

以下是一個示例：

use std::rc::Rc;
fn main() {
    let value = Rc::new("Hello, world!".to_string());
    let reference1 = value.clone();
    let reference2 = value.clone();
    println!("{}", reference1);
    println!("{}", reference2);
}

在這個例子中，我們使用 Rc::new 創(chuàng)建一個新的 Rc<String> 類型的值，并將其賦值給 value 變量。然后，我們使用 value.clone() 方法來創(chuàng)建 value 的兩個引用，并將它們分別賦值給 reference1 和 reference2 變量。最后，我們打印 reference1 和 reference2 變量，以顯示它們都引用了同一個值。

需要注意的是，Rc<T> 類型只能用于單線程環(huán)境，因為它不是線程安全的。如果需要在多線程環(huán)境下實現(xiàn)引用計數(shù)，可以使用 Arc<T>（“原子引用計數(shù)”）類型。Arc<T> 類型是 Rc<T> 的線程安全版本，它使用原子操作來實現(xiàn)引用計數(shù)。

借用和數(shù)據(jù)競爭

在 Rust 中，借用是一種通過引用來訪問值而不獲取其所有權(quán)的方式。借用是 Rust 中非常重要的概念，因為它可以幫助避免數(shù)據(jù)競爭的問題。

數(shù)據(jù)競爭指的是多個線程同時訪問同一個變量，且至少有一個線程正在寫入該變量。如果沒有采取適當?shù)耐酱胧?，?shù)據(jù)競爭會導(dǎo)致未定義的行為，例如程序崩潰或產(chǎn)生意外的結(jié)果。

在 Rust 中，編譯器使用所有權(quán)和借用規(guī)則來防止數(shù)據(jù)競爭。具體來說，編譯器會檢查每個引用的生命周期，以確保在引用仍然有效的情況下進行訪問。如果編譯器發(fā)現(xiàn)了潛在的數(shù)據(jù)競爭問題，它會在編譯時發(fā)出錯誤。

以下是一個簡單的例子，說明如何使用借用來避免數(shù)據(jù)競爭問題：

use std::thread;
fn main() {
    let mut data = vec![1, 2, 3];
    let handle1 = thread::spawn(move || {
        let reference = &data;
        println!("Thread 1: {:?}", reference);
    });
    let handle2 = thread::spawn(move || {
        let reference = &data;
        println!("Thread 2: {:?}", reference);
    });
    handle1.join().unwrap();
    handle2.join().unwrap();
}

在這個例子中，我們創(chuàng)建了一個可變的 Vec<i32> 類型的值，并將其賦值給 data 變量。然后，我們在兩個線程中使用 thread::spawn 方法，每個線程都獲取對 data 的共享引用，并打印該引用。由于我們使用了共享引用，所以不會發(fā)生數(shù)據(jù)競爭問題。

需要注意的是，如果我們嘗試將 data 的可變引用傳遞給兩個線程中的一個或多個線程，編譯器將會在編譯時發(fā)出錯誤，因為這可能會導(dǎo)致數(shù)據(jù)競爭。在這種情況下，我們可以使用 Mutex<T>、RwLock<T> 或 Cell<T> 等同步原語來避免數(shù)據(jù)競爭。

內(nèi)部可變

在 Rust 中，內(nèi)部可變性是指在擁有不可變引用的同時，可以修改被引用的值。Rust 提供了一些內(nèi)部可變性的實現(xiàn)方式，包括 Cell<T> 和 RefCell<T> 類型。

Cell<T> 類型提供了一種在不可變引用的情況下，修改其所持有的值的方法。它通過在不可變引用中封裝值，并使用 get 和 set 方法來實現(xiàn)內(nèi)部可變性。以下是一個示例：

use std::cell::Cell;
fn main() {
    let number = Cell::new(42);
    let reference = &number;
    let value = reference.get();
    number.set(value + 1);
    println!("The new value is: {}", reference.get());
}

在這個例子中，我們創(chuàng)建了一個 Cell<i32> 類型的值，并將其賦值給 number 變量。然后，我們獲取了一個 &Cell<i32> 類型的不可變引用，并通過 get 方法獲取了 number 所持有的值。接著，我們通過 set 方法來修改 number 所持有的值。最后，我們打印了 number 所持有的新值。

RefCell<T> 類型提供了一種更靈活的內(nèi)部可變性實現(xiàn)方式。它通過在可變和不可變引用中封裝值，并使用 borrow 和 borrow_mut 方法來實現(xiàn)內(nèi)部可變性。以下是一個示例：

use std::cell::RefCell;
fn main() {
    let number = RefCell::new(42);
    let reference1 = &number.borrow();
    let reference2 = &number.borrow();
    let mut reference3 = number.borrow_mut();
    *reference3 += 1;
    println!("The new value is: {:?}", number.borrow());
}

在這個例子中，我們創(chuàng)建了一個 RefCell<i32> 類型的值，并將其賦值給 number 變量。然后，我們獲取了兩個不可變引用，并通過 borrow_mut 方法獲取了一個可變引用。接著，我們通過可變引用來修改 number 所持有的值。最后，我們打印了 number 所持有的新值。

需要注意的是，Cell<T> 和 RefCell<T> 類型都不是線程安全的。如果需要在多線程環(huán)境下使用內(nèi)部可變性，可以使用 Mutex<T> 或 RwLock<T> 等同步原語。 在 Rust 中，為了保證多線程并發(fā)訪問共享數(shù)據(jù)的安全性，可以使用同步原語，例如 Mutex 和 RwLock。

Mutex 是一種互斥鎖，它允許只有一個線程訪問被保護的共享數(shù)據(jù)。在 Rust 中，可以通過標準庫中的 std::sync::Mutex 類型來實現(xiàn) Mutex。以下是一個示例：

use std::sync::Mutex;
fn main() {
    let data = Mutex::new(0);
    let mut handles = vec![];
    for _ in 0..10 {
        let handle = std::thread::spawn(move || {
            let mut data = data.lock().unwrap();
            *data += 1;
        });
        handles.push(handle);
    }
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Result: {}", *data.lock().unwrap());
}

在這個例子中，我們創(chuàng)建了一個 Mutex<i32> 類型的值，并將其賦值給 data 變量。然后，我們創(chuàng)建了 10 個線程，并在每個線程中獲取 data 的可變引用，并通過加 1 的方式修改其所持有的值。最后，我們等待所有線程執(zhí)行完畢，并打印 data 所持有的值。

RwLock 是一種讀寫鎖，它允許多個線程同時讀取共享數(shù)據(jù)，但只允許一個線程寫入共享數(shù)據(jù)。在 Rust 中，可以通過標準庫中的 std::sync::RwLock 類型來實現(xiàn) RwLock。以下是一個示例：

use std::sync::RwLock;
fn main() {
    let data = RwLock::new(0);
    let mut handles = vec![];
    for _ in 0..10 {
        let handle = std::thread::spawn(move || {
            let data = data.read().unwrap();
            println!("Thread {}: read data {}", std::thread::current().id(), *data);
        });
        handles.push(handle);
    }
    let handle = std::thread::spawn(move || {
        let mut data = data.write().unwrap();
        *data += 1;
        println!("Thread {}: write data {}", std::thread::current().id(), *data);
    });
    handles.push(handle);
    for handle in handles {
        handle.join().unwrap();
    }
}

在這個例子中，我們創(chuàng)建了一個 RwLock<i32> 類型的值，并將其賦值給 data 變量。然后，我們創(chuàng)建了 10 個線程，并在每個線程中獲取 data 的不可變引用，并打印其所持有的值。接著，我們創(chuàng)建了一個新的線程，并獲取 data 的可變引用，并通過加 1 的方式修改其所持有的值。最后，我們等待所有線程執(zhí)行完畢。

需要注意的是，在使用 Mutex 和 RwLock 時，需要使用 unwrap() 方法來處理鎖的獲取失敗的情況。如果在獲取鎖時發(fā)生了死鎖，程序會阻塞在該位置。因此，在使用鎖時需要注意避免死鎖的情況。 在 Rust 中，為了保證線程安全和內(nèi)存安全，訪問可變的共享數(shù)據(jù)通常需要使用同步原語，例如 Mutex 和 RwLock，或者通過引用計數(shù)等方式。然而，有時候我們需要在 Rust 中使用一些類似 C 的指針操作，這時就需要使用 unsafe 關(guān)鍵字來打破 Rust 的內(nèi)存安全限制。

Rust 標準庫中提供了一個 Cell<T> 類型，它允許在不使用 Mutex 或 RwLock 的情況下，在多個線程之間共享可變數(shù)據(jù)。但是，由于 Cell<T> 不是線程安全的，因此在多線程環(huán)境下使用它會導(dǎo)致數(shù)據(jù)競爭和內(nèi)存安全問題。

為了解決這個問題，Rust 提供了 UnsafeCell<T> 類型，它可以安全地包含不可變類型 T 或可變類型 &mut T，并且可以用于實現(xiàn)線程安全的數(shù)據(jù)結(jié)構(gòu)。使用 UnsafeCell<T> 需要使用 unsafe 關(guān)鍵字，并遵循 Rust 的內(nèi)存安全規(guī)則。

以下是一個示例，演示如何使用 UnsafeCell<T> 來實現(xiàn)一個線程安全的計數(shù)器：

rustCopy code
use std::sync::atomic::{AtomicUsize, Ordering};
use std::cell::UnsafeCell;
use std::thread;
struct Counter {
    count: UnsafeCell<usize>,
    sync: AtomicUsize,
}
impl Counter {
    fn new() -> Counter {
        Counter {
            count: UnsafeCell::new(0),
            sync: AtomicUsize::new(0),
        }
    }
    fn inc(&self) {
        let old_sync = self.sync.load(Ordering::SeqCst);
        let new_sync = old_sync.wrapping_add(1);
        while self.sync.compare_and_swap(old_sync, new_sync, Ordering::SeqCst) != old_sync {
            old_sync = self.sync.load(Ordering::SeqCst);
            new_sync = old_sync.wrapping_add(1);
        }
        let count = unsafe { &mut *self.count.get() };
        *count += 1;
        self.sync.fetch_add(1, Ordering::SeqCst);
    }
    fn get(&self) -> usize {
        let old_sync = self.sync.load(Ordering::SeqCst);
        let new_sync = old_sync.wrapping_add(1);
        while self.sync.compare_and_swap(old_sync, new_sync, Ordering::SeqCst) != old_sync {
            old_sync = self.sync.load(Ordering::SeqCst);
            new_sync = old_sync.wrapping_add(1);
        }
        let count = unsafe { &*self.count.get() };
        let result = *count;
        self.sync.fetch_add(1, Ordering::SeqCst);
        result
    }
}
fn main() {
    let counter = Counter::new();
    let mut handles = vec![];
    for _ in 0..10 {
        let handle = thread::spawn(move || {
            for _ in 0..10000 {
                counter.inc();
            }
        });
        handles.push(handle);
    }
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Result: {}", counter.get());
}

在這個例子中，我們創(chuàng)建了一個 Counter 結(jié)構(gòu)體，它包含了一個 UnsafeCell<usize> 類型的字段 count，以及一個 AtomicUsize 類型的字段 sync。 UnsafeCell<T> 類型的作用是允許對其內(nèi)部的值進行修改，即使是在不可變引用的情況下。AtomicUsize 是一個原子類型，它可以在多個線程之間安全地共享一個整數(shù)值。

Counter 結(jié)構(gòu)體實現(xiàn)了 inc 方法和 get 方法，分別用于增加計數(shù)器的值和獲取計數(shù)器的值。這些方法通過對 sync 字段進行 CAS 操作來實現(xiàn)線程安全，以避免競爭條件。同時，它們也使用了 UnsafeCell 來獲取計數(shù)器的可變引用。 需要注意的是，使用 UnsafeCell 時需要遵循 Rust 的內(nèi)存安全規(guī)則。如果你不小心在多個線程之間訪問了同一個 UnsafeCell，那么就可能會出現(xiàn)數(shù)據(jù)競爭和其它的內(nèi)存安全問題。因此，一定要謹慎地使用 UnsafeCell，確保正確地處理內(nèi)存安全問題。

rust 中的線程安全 Send 和 Sync

在 Rust 中，線程安全是一個很重要的概念，因為 Rust 的并發(fā)模型是基于線程的。為了確保線程安全，Rust 提供了兩個 trait，分別是 Send 和 Sync。

Send trait 表示一個類型是可以安全地在線程間傳遞的。具體來說，實現(xiàn)了 Send trait 的類型可以被移動到另一個線程中執(zhí)行，而不會出現(xiàn)數(shù)據(jù)競爭或其它的線程安全問題。對于基本類型（如整數(shù)、浮點數(shù)、指針等）和大多數(shù)標準庫類型，都是 Send 的。對于自定義類型，只要它的所有成員都是 Send 的，那么它也是 Send 的。

Sync trait 表示一個類型在多個線程間可以安全地共享訪問。具體來說，實現(xiàn)了 Sync trait 的類型可以被多個線程同時訪問，而不會出現(xiàn)數(shù)據(jù)競爭或其它的線程安全問題。對于大多數(shù)標準庫類型，都是 Sync 的。對于自定義類型，只要它的所有成員都是 Sync 的，那么它也是 Sync 的。

需要注意的是，Send 和 Sync trait 是自動實現(xiàn)的，也就是說，如果一個類型的所有成員都是 Send 或 Sync 的，那么它就是 Send 或 Sync 的，無需手動實現(xiàn)這兩個 trait。不過，如果一個類型包含了非 Send 或非 Sync 的成員，那么它就無法自動實現(xiàn)這兩個 trait，需要手動實現(xiàn)。

• 在實際使用中，Send 和 Sync trait 通常用于泛型類型約束和函數(shù)簽名中，以確保類型的線程安全性。比如，一個函數(shù)的參數(shù)必須是 Send 類型的，才能被跨線程調(diào)用；一個泛型類型的參數(shù)必須是 Sync 類型的，才能被多個線程同時訪問。

線程阻塞和喚醒

在 Rust 中，線程的阻塞和喚醒是通過操作系統(tǒng)提供的原語來實現(xiàn)的。操作系統(tǒng)提供了一些系統(tǒng)調(diào)用（如 pthread_cond_wait、pthread_cond_signal 等），可以讓線程進入睡眠狀態(tài)，并在條件滿足時被喚醒。這些系統(tǒng)調(diào)用通常被封裝在 Rust 的標準庫中，以便于使用。

除了操作系統(tǒng)提供的原語外，Rust 還提供了一個名為 parking_lot 的庫，用于實現(xiàn)線程的阻塞和喚醒。parking_lot 庫提供了兩種阻塞和喚醒線程的機制，分別是 Mutex 和 Condvar。

Mutex 是一種常見的同步原語，用于保護共享資源的訪問。當一個線程想要獲取一個被 Mutex 保護的資源時，如果該資源已經(jīng)被其它線程占用，那么該線程就會被阻塞，直到該資源被釋放。Mutex 的實現(xiàn)通常使用了操作系統(tǒng)提供的原語，以確保線程的阻塞和喚醒是正確的。

Condvar 是一種條件變量，用于在特定條件滿足時喚醒等待的線程。當一個線程想要等待一個條件變量時，它會先獲取一個 Mutex，然后調(diào)用 wait 方法等待條件變量。如果條件變量未滿足，該線程就會被阻塞。當條件變量滿足時，另一個線程會調(diào)用 notify_one 或 notify_all 方法來喚醒等待的線程。Condvar 的實現(xiàn)通常也使用了操作系統(tǒng)提供的原語，以確保線程的阻塞和喚醒是正確的。

需要注意的是，parking_lot 庫雖然是 Rust 標準庫的一部分，但它并不是操作系統(tǒng)提供的原語，而是使用了自己的算法實現(xiàn)的。因此，雖然 parking_lot 庫提供了比標準庫更高效的同步機制，但在某些特定的場景下，操作系統(tǒng)提供的原語可能會更加適合。在選擇同步機制時，需要根據(jù)實際的需求和性能要求來進行選擇。

以上就是Rust Atomics and Locks并發(fā)基礎(chǔ)理解的詳細內(nèi)容，更多關(guān)于Rust 并發(fā)基礎(chǔ)的資料請關(guān)注腳本之家其它相關(guān)文章！

最新評論