Rust 的所有權和借用系統在保障記憶體安全方面表現出色，但也為平行程式設計帶來挑戰。分享所有權機制透過 Rc 和 Arc 智慧指標有效解決了這個問題。Rc 適用於單執行緒環境，而 Arc 則能安全地在多執行緒環境下使用。它們允許多個變數分享同一份資料，並在資料不再使用時自動釋放記憶體，避免了手動管理記憶體的複雜性。然而，分享所有權也存在限制，開發者無法直接修改分享資料，需要藉助內部可變性機制或鎖機制來實作修改。本文也探討了 Cell、RefCell、Mutex 和 RwLock 的應用場景和特性，它們在不同程度上平衡了效能和安全性，為 Rust 平行程式設計提供了靈活的解決方案。理解這些機制對於編寫高效且安全的 Rust 平行程式至關重要。
graph TD;
A[開始] --> B{是否使用作用域執行緒?};
B -- 是 --> C[建立作用域執行緒];
B -- 否 --> D[使用靜態變數或參考計數];
C --> E[執行緒內操作];
D --> F[分享資料];
E --> G[作用域結束，執行緒自動加入];
F --> H[資料釋放或記憶體洩漏];
圖表翻譯：
此圖表展示了 Rust 平行程式設計中的主要流程選擇。首先，開發者需要決定是否使用作用域執行緒。如果使用，則建立並執行相關執行緒；如果不使用，則選擇靜態變數或參考計數來分享資料。最終，根據不同的選擇，資料會被適當地釋放或處理。
分享所有權與執行緒安全
在 Rust 中，Rc（Reference Counting）與 Arc（Atomically Reference Counting）是兩種用於實作分享所有權的智慧指標。它們允許多個變數分享同一份資料，並且在資料不再被使用時自動釋放記憶體。
Rc 與 Arc 的基本使用
Rc 的使用
Rc 是一種簡單的參照計數智慧指標，適用於單執行緒環境。當你需要多個變數分享同一份資料時，可以使用 Rc。
use std::rc::Rc;
let a = Rc::new([1, 2, 3]);
let b = a.clone();
assert_eq!(a.as_ptr(), b.as_ptr()); // 相同記憶體位址
Arc 的使用
Arc 是執行緒安全的版本，適用於多執行緒環境。它使用原子操作來更新參照計數，確保執行緒安全。
use std::sync::Arc;
use std::thread;
let a = Arc::new([1, 2, 3]);
let b = a.clone();
thread::spawn(move || {
dbg!(a);
});
thread::spawn(move || {
dbg!(b);
});
克隆與分享
在使用 Arc 或 Rc 時，你可能會需要克隆多個例項。Rust 允許你使用相同的變數名來簡化程式碼。
let a = Arc::new([1, 2, 3]);
thread::spawn({
let a = a.clone();
move || {
dbg!(a);
}
});
dbg!(a);
內容解密：
在上述程式碼中，我們使用了一個新的作用域來克隆 a，並將克隆後的 a 移動到新的執行緒中。這樣做的好處是，我們可以在不同的作用域中使用相同的變數名，而不會導致名稱衝突。
分享所有權的限制
由於 Arc 和 Rc 都是分享所有權，它們與分享參照（&T）有相同的限制。你無法直接修改其內部的資料，因為資料可能同時被其他程式碼借用。
let a = Arc::new([3, 2, 1]);
// a.sort(); // 編譯錯誤：無法借用 `Arc` 中的資料為可變
借用與資料競爭
Rust 中的借用機制可以有效防止資料競爭。借用分為兩種：不可變借用（&T）和可變借用（&mut T）。
不可變借用
不可變借用允許多個變數分享同一份資料，但不允許修改資料。
fn f(a: &i32, b: &mut i32) {
let before = *a;
*b += 1;
let after = *a;
if before != after {
x(); // 永遠不會執行
}
}
內容解密：
在這個例子中，編譯器可以假設 a 和 b 不會指向相同的記憶體位址，因為 a 是不可變借用，而 b 是可變借用。這使得編譯器可以最佳化程式碼，移除對 x() 的呼叫。
執行緒安全與資料競爭
Rust 的借用規則確保了執行緒安全，防止了資料競爭的發生。資料競爭是指多個執行緒同時存取同一份資料，其中至少有一個執行緒試圖修改資料。
資料競爭的預防
Rust 編譯器透過借用規則來預防資料競爭。當你試圖在多個執行緒中分享可變資料時，編譯器會檢查你的程式碼是否違反了借用規則。
// error[E0596]: cannot borrow data in an `Arc` as mutable
let a = Arc::new([3, 2, 1]);
// a.sort(); // 編譯錯誤
隨著 Rust 語言的不斷發展，未來可能會出現更多高效的平行程式設計工具和技術。開發者應持續關注 Rust 的最新發展，以充分利用其強大的平行程式設計能力。
流程圖示
graph LR
A[開始] --> B{是否需要分享所有權？}
B -- 是 --> C[使用 Arc 或 Rc]
B -- 否 --> D[使用普通所有權]
C --> E[克隆 Arc 或 Rc]
E --> F[在多執行緒中使用]
F --> G[確保執行緒安全]
G --> H[結束]
D --> I[直接使用變數]
I --> H
圖表翻譯：
此圖示展示了在 Rust 中決定是否使用分享所有權的流程。如果需要分享所有權，則使用 Arc 或 Rc，並克隆它們以在多執行緒中使用，同時確保執行緒安全。如果不需要分享所有權，則直接使用普通所有權的變數。最終，流程結束。
未定義行為與內部可變性：Rust 程式設計的安全邊界
在 Rust 程式語言中，避免未定義行為（Undefined Behavior）是確保程式正確運作的關鍵。未定義行為可能導致程式出現不可預測的結果，包括程式當機、錯誤結果，甚至是看似正確但實際上存在隱患的執行結果。
未定義行為的來源
未定義行為通常源於違反 Rust 的基本規則，例如在同一時間內對同一個物件建立多個可變參照。在 Rust 中，這些規則通常由編譯器強制執行，但在某些情況下，開發者可以使用 unsafe 程式碼區塊來繞過這些限制。
使用 unsafe 的風險
unsafe 程式碼區塊允許開發者執行一些編譯器無法保證安全的程式碼。例如，使用 get_unchecked 方法存取陣列元素時，編譯器不會檢查索引是否越界。如果索引超出範圍，程式可能會讀取到無效的記憶體位置，導致未定義行為。
let a = [123, 456, 789];
let index = 3;
let b = unsafe { a.get_unchecked(index) };
內容解密：
在上述程式碼中，get_unchecked 方法允許開發者直接存取陣列 a 中索引為 index 的元素，但不進行邊界檢查。如果 index 超出陣列範圍，程式將進入未定義行為狀態。這要求開發者必須確保 index 在有效範圍內，否則程式可能會出現不可預測的行為。
未定義行為的影響可能超出 unsafe 程式碼區塊本身。編譯器在最佳化程式碼時，可能會根據 unsafe 程式碼區塊中的假設進行最佳化。如果這些假設被違反，程式可能會在邏輯上出現錯誤，甚至在 unsafe 程式碼執行之前就出現問題。
match index {
0 => x(),
1 => y(),
_ => z(index),
}
let a = [123, 456, 789];
let b = unsafe { a.get_unchecked(index) };
內容解密：
在上述範例中，編譯器可能會假設 index 只會是 0、1 或 2，並據此最佳化 match 陳述式。如果 index 實際上是 3，程式可能會執行到已被最佳化的程式碼部分，導致不可預測的行為。
內部可變性：打破借用規則的限制
Rust 的借用規則保證了資料安全，但有時會過於嚴格，特別是在多執行緒環境中。內部可變性（Interior Mutability）提供了一種機制，允許在某些條件下透過分享參照修改資料。
Cell 與 RefCell：內部可變性的實作
Cell 和 RefCell 是 Rust 中實作內部可變性的兩個重要型別。它們允許在不違反借用規則的前提下修改資料。
Cell 的使用
Cell 允許透過分享參照修改其內部的值，但它只能用於單執行緒環境，並且只能整體替換其內部的值。
use std::cell::Cell;
fn f(a: &Cell<i32>, b: &Cell<i32>) {
let before = a.get();
b.set(b.get() + 1);
let after = a.get();
if before != after {
x(); // 可能會發生
}
}
內容解密：
在上述範例中，a 和 b 可能是對同一個 Cell 的參照，因此透過 b 修改其值可能會影響到 a。這使得 before 和 after 的值可能不同，觸發 x() 的執行。
RefCell 的使用
RefCell 允許在執行時期借用檢查，避免了編譯時期的限制。如果違反了借用規則，RefCell 將會觸發 panic! 以避免未定義行為。
use std::cell::RefCell;
fn f(v: &RefCell<Vec<i32>>) {
let mut v2 = v.borrow_mut();
v2.push(1);
}
內容解密：
在上述範例中，RefCell 允許我們透過 borrow_mut 方法取得 Vec 的可變借用，並對其進行修改。如果在 v2 仍被借用時再次借用 v，程式將會 panic!。
內部可變性：Rust 中的 Cell、RefCell 與並發控制
在 Rust 中，內部可變性（Interior Mutability）是一種允許在不違反借用規則的情況下修改資料的機制。這種機制主要透過 Cell、RefCell、Mutex 和 RwLock 等型別來實作。本章將探討這些型別的工作原理及其在並發程式設計中的應用。
Cell 與 RefCell：非同步場景下的內部可變性
Cell 和 RefCell 是 Rust 提供的基本內部可變性容器。它們允許在持有不可變參照的情況下修改資料。
Cell：簡單包裝下的可變性
Cell 提供了一個簡單的包裝容器，允許直接存取和修改內部資料。它透過 get 和 set 方法來存取內容。
use std::cell::Cell;
fn main() {
let c = Cell::new(1);
let value = c.get(); // 取得目前的值
println!("Current value: {}", value);
c.set(2); // 修改值
println!("New value: {}", c.get());
}
RefCell：動態借用檢查
RefCell 提供了動態借用檢查功能，允許在執行時檢查借用規則。它支援動態借用 borrow 和 borrow_mut 方法。
use std::cell::RefCell;
fn main() {
let r = RefCell::new(vec![1, 2, 3]);
println!("Before modification: {:?}", r.borrow());
r.borrow_mut().push(4); // 修改 Vec
println!("After modification: {:?}", r.borrow());
}
內容解密：
Cell和RefCell都是用於實作內部可變性的容器。Cell透過get和set方法直接操作內容。RefCell支援動態借用檢查，避免編譯時錯誤。- 這些容器主要用於單執行緒環境。
並發控制：Mutex 與 RwLock
在多執行緒環境中，Mutex 和 RwLock 提供了類別似於 RefCell 的功能，但具有執行緒安全性。
Mutex：互斥鎖
Mutex（互斥鎖）確保在任何時刻只有一個執行緒能夠存取資料。它提供了獨佔存取控制。
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..10 {
let counter_clone = Arc::clone(&counter);
let handle = thread::spawn(move || {
let mut num = counter_clone.lock().unwrap();
*num += 1;
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!("Result: {}", *counter.lock().unwrap());
}
RwLock：讀寫鎖
RwLock（讀寫鎖）允許同時有多個讀取執行緒，但寫入時需要獨佔存取。
use std::sync::{Arc, RwLock};
use std::thread;
fn main() {
let data = Arc::new(RwLock::new(0));
let mut handles = vec![];
// 讀取執行緒
for _ in 0..5 {
let data_clone = Arc::clone(&data);
let handle = thread::spawn(move || {
let r = data_clone.read().unwrap();
println!("Read: {}", *r);
});
handles.push(handle);
}
// 寫入執行緒
let data_clone = Arc::clone(&data);
let handle = thread::spawn(move || {
let mut w = data_clone.write().unwrap();
*w += 1;
});
handles.push(handle);
for handle in handles {
handle.join().unwrap();
}
}
內容解密：
Mutex提供獨佔存取控制，確保資料安全。RwLock允許多個讀取執行緒同時存取。- 這些鎖機制確保了多執行緒環境下資料的一致性。
- 正確使用鎖機制可以避免資料競爭。
原子型別與 UnsafeCell
原子型別
原子型別（如 AtomicU32）提供了無鎖的資料存取方式，適用於高並發場景。
use std::sync::atomic::{AtomicU32, Ordering};
use std::sync::Arc;
use std::thread;
fn main() {
let counter = Arc::new(AtomicU32::new(0));
let mut handles = vec![];
for _ in 0..10 {
let counter_clone = Arc::clone(&counter);
let handle = thread::spawn(move || {
counter_clone.fetch_add(1, Ordering::SeqCst);
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!("Result: {}", counter.load(Ordering::SeqCst));
}
UnsafeCell：內部可變性的根本
UnsafeCell 是所有內部可變性型別的基礎。它提供了原始指標存取方式，需要在 unsafe 區塊中使用。
use std::cell::UnsafeCell;
fn main() {
let uc = UnsafeCell::new(1);
unsafe {
*uc.get() = 2; // 直接修改內容
println!("Value: {}", *uc.get());
}
}
內容解密：
- 原子型別提供了高效的無鎖操作。
UnsafeCell是實作內部可變性的基本單元。- 使用
UnsafeCell需要謹慎處理以避免未定義行為。 - 高階抽象型別如
Cell和Mutex都是根據UnsafeCell構建的。
執行緒安全：Send 與 Sync
Rust 使用 Send 和 Sync 特徵來確保型別的執行緒安全性。
Send：跨執行緒傳遞所有權
Send 特徵表示型別可以安全地跨執行緒傳遞所有權。
use std::thread;
fn main() {
let data = vec![1, 2, 3];
let handle = thread::spawn(move || {
println!("Data in new thread: {:?}", data);
});
handle.join().unwrap();
}
Sync：跨執行緒分享參照
Sync 特徵表示型別可以安全地跨執行緒分享參照。
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let data = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..10 {
let data_clone = Arc::clone(&data);
let handle = thread::spawn(move || {
let mut num = data_clone.lock().unwrap();
*num += 1;
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!("Result: {}", *data.lock().unwrap());
}
內容解密：
Send和Sync是 Rust 執行緒安全的基礎。- 正確實作這些特徵對於自定義型別至關重要。
- 大多數基本型別預設實作了
Send和Sync。 - 使用
PhantomData可以影響型別的Send和Sync特徵實作。
