Rust 提供了多種機制實作多執行緒與平行處理，提升程式效能。透過 std::thread::spawn 函式可以建立新的執行緒，並利用通道（Channel）或分享狀態進行執行緒間的通訊與協調。通道允許執行緒間傳遞資料，而分享狀態則需要使用 Mutex 等同步機制確保資料安全。此外，Sync 和 Send 特性則確保型別在平行環境中的安全性，讓開發者能更安全地進行多執行緒程式設計。
多執行緒與平行處理
在現代程式設計中，多執行緒與平行處理是提升應用程式效能和反應速度的關鍵技術。Rust 語言透過提供強大的平行程式設計能力，簡化了開發者編寫高效且安全的平行程式碼的過程。本章將探討 Rust 中的多執行緒、訊息傳遞平行處理、分享狀態平行處理，以及 Sync 和 Send 特性的應用。
多執行緒基礎
一個行程（Process）是程式執行的獨立例項，包含自己的記憶體空間、程式碼、資料和資源。當執行一個程式時，作業系統會建立一個行程，使其能夠獨立於其他行程執行任務。每個行程都有自己的位址空間，這意味著如果沒有明確的機制，如行程間通訊（IPC），它無法直接存取其他行程的記憶體。
一個執行緒（Thread）是行程中更小的執行單元。多個執行緒可以存在於單一行程中，分享相同的記憶體空間和資源。執行緒允許在單一行程中平行執行任務，從而更有效地利用資源。
使用執行緒實作平行處理
Rust 透過使用執行緒來實作平行處理，使不同的程式碼片段能夠同時執行。透過利用執行緒，我們可以充分發揮多核心處理器的潛力，提高應用程式的效能和回應速度。
在 Rust 中建立執行緒
在 Rust 中建立執行緒可以使用 std::thread 模組。要建立一個新的執行緒，我們使用 std::thread::spawn 函式，並提供一個閉包或函式在新的執行緒中執行。這個閉包或函式代表了將要平行執行的程式碼。
use std::thread;
fn main() {
// 建立一個新的執行緒
let handle = thread::spawn(|| {
// 在新執行緒中執行的程式碼
println!("你好，來自新的執行緒！");
});
// 等待執行緒完成
handle.join().unwrap();
}
內容解密：
use std::thread;：匯入std::thread模組，以便使用其提供的函式和型別。let handle = thread::spawn(|| { ... });：建立一個新的執行緒，並傳回一個JoinHandle，可以用來等待該執行緒完成。handle.join().unwrap();：等待新建立的執行緒完成。如果執行緒發生 panic，這裡會導致主執行緒 panic。
訊息傳遞平行處理
訊息傳遞是一種平行處理模式，透過在執行緒之間傳遞訊息來進行通訊和協調。Rust 提供了多種方式來實作訊息傳遞，例如使用通道（Channel）。
使用通道進行訊息傳遞
通道是一種允許在不同執行緒之間傳遞資料的機制。Rust 的標準函式庫提供了 std::sync::mpsc 模組來支援多生產者、單一消費者的通道。
use std::sync::mpsc;
use std::thread;
fn main() {
// 建立一個通道
let (tx, rx) = mpsc::channel();
// 在新執行緒中傳送訊息
thread::spawn(move || {
let msg = String::from("你好，來自新執行緒的訊息！");
tx.send(msg).unwrap();
});
// 在主執行緒中接收訊息
let received = rx.recv().unwrap();
println!("收到訊息：{}", received);
}
內容解密：
let (tx, rx) = mpsc::channel();：建立一個通道，傳回傳送端（tx）和接收端（rx）。tx.send(msg).unwrap();：透過通道傳送訊息。如果傳送失敗，會導致 panic。let received = rx.recv().unwrap();：從通道接收訊息。如果接收失敗或通道關閉，會導致 panic。
分享狀態平行處理
分享狀態平行處理涉及多個執行緒存取和修改分享資料。Rust 提供了多種同步機制，如互斥鎖（Mutex）和原子型別，以安全地進行分享狀態平行處理。
使用互斥鎖進行分享狀態管理
互斥鎖是一種同步原語，用於保護分享資料免受多個執行緒的同時存取。
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
// 使用 Arc 和 Mutex 管理分享狀態
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!("最終計數器值：{}", *counter.lock().unwrap());
}
內容解密：
let counter = Arc::new(Mutex::new(0));：建立一個由Arc管理的Mutex，用於在多個執行緒中分享計數器。let mut num = counter_clone.lock().unwrap();：鎖定互斥鎖以存取分享資料。如果鎖定失敗，會導致 panic。*num += 1;：修改分享資料。handle.join().unwrap();：等待所有執行緒完成。
Sync 和 Send 特性
Rust 的 Sync 和 Send 特性用於確保型別在平行環境中的安全性。實作 Send 特性的型別可以在執行緒之間安全地傳遞，而實作 Sync 特性的型別可以被多個執行緒安全地共用。
多執行緒程式設計在Rust中的應用與實作
Rust語言提供了強大的多執行緒支援，使得開發者能夠編寫高效且安全的平行程式。多執行緒程式設計允許程式在多個執行緒中同時執行不同的任務，從而提高程式的整體效能和反應速度。
建立與管理執行緒
在Rust中，建立一個新的執行緒非常簡單，可以使用std::thread::spawn函式來實作。以下是一個基本的例子：
use std::thread;
fn main() {
let handle = thread::spawn(|| {
println!("Hello from a new thread!");
});
// 等待新執行緒完成執行
handle.join().expect("Failed to join the thread.");
}
內容解密：
thread::spawn用於建立一個新的執行緒，並傳入一個閉包（closure）作為該執行緒的執行內容。handle.join()用於等待該執行緒完成執行，確保主執行緒不會在子執行緒完成前離開。expect方法用於處理可能發生的錯誤，例如執行緒無法正常加入。
執行緒同步與通訊
在多執行緒環境中，執行緒同步與通訊是非常重要的課題。Rust提供了多種機制來實作執行緒同步與通訊，例如Mutex、Condition Variables和Channels。
Mutex（互斥鎖）
Mutex允許同一時間只有一個執行緒存取分享資源，從而避免資料競爭（data races）。以下是一個使用Mutex的例子：
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
// 建立一個由Mutex保護的分享可變資料
let counter = Arc::new(Mutex::new(0));
// 建立多個執行緒來遞增計數器
let handles: Vec<_> = (0..5)
.map(|_| {
let counter = Arc::clone(&counter);
thread::spawn(move || {
// 取得Mutex鎖
let mut num = counter.lock().unwrap();
// 修改分享資料
*num += 1;
})
})
.collect();
// 等待所有執行緒完成
for handle in handles {
handle.join().unwrap();
}
// 列印計數器的最終值
println!("Counter: {}", *counter.lock().unwrap());
}
內容解密：
- 使用
Arc（原子參照計數）來實作多個執行緒對同一個Mutex的分享所有權。 - 每個執行緒透過
lock()方法取得Mutex鎖，確保同一時間只有一個執行緒能夠修改分享資料。 - 修改完成後，Mutex鎖會自動釋放。
Channels（通道）
Channels提供了一種在執行緒之間傳遞訊息的機制。以下是一個使用Channels的例子：
@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultTextAlignment center
skinparam rectangleBackgroundColor #F5F5F5
skinparam rectangleBorderColor #333333
skinparam arrowColor #333333
title Channels（通道）
rectangle "建立通道" as node1
rectangle "傳送訊息" as node2
rectangle "接收訊息" as node3
node1 --> node2
node2 --> node3
@enduml
圖表翻譯： 此圖示展示了主執行緒與子執行緒之間透過通道進行通訊的過程。主執行緒建立通道，並將傳送端傳遞給子執行緒。子執行緒透過傳送端傳送訊息，而主執行緒則透過接收端接收訊息。
use std::sync::mpsc;
use std::thread;
fn main() {
// 建立一個通道
let (sender, receiver) = mpsc::channel();
// 建立一個執行緒來傳送訊息
thread::spawn(move || {
let messages = vec!["Hello", "from", "another", "thread"];
for msg in messages {
sender.send(msg).unwrap();
thread::sleep(std::time::Duration::from_secs(1));
}
});
// 在主執行緒中接收訊息
for received in receiver {
println!("Received: {}", received);
}
}
內容解密：
- 使用
mpsc::channel()建立一個通道，其中sender用於傳送訊息，而receiver用於接收訊息。 - 子執行緒透過
sender.send()傳送訊息，主執行緒則透過遍歷receiver來接收訊息。
執行緒安全與資料競爭
Rust透過其所有權系統和借用檢查器，在編譯時就能夠防止許多資料競爭的問題。以下是一個可能導致資料競爭的例子，以及如何使用Mutex來避免它：
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let counter = Arc::new(Mutex::new(0));
let handle1 = thread::spawn({
let counter = Arc::clone(&counter);
move || {
for _ in 0..1_000_000 {
let mut num = counter.lock().unwrap();
*num += 1;
}
}
});
let handle2 = thread::spawn({
let counter = Arc::clone(&counter);
move || {
for _ in 0..1_000_000 {
let mut num = counter.lock().unwrap();
*num += 1;
}
}
});
handle1.join().unwrap();
handle2.join().unwrap();
println!("Counter: {}", *counter.lock().unwrap());
}
內容解密：
- 透過Mutex保護分享資料，確保同一時間只有一個執行緒能夠存取和修改它。
- 使用
Arc來實作多個執行緒對同一個Mutex的分享所有權。
多執行緒程式設計與同步機制
在現代軟體開發中，多執行緒程式設計是一種常見的技術，能夠有效地提升程式的效能和回應速度。然而，多執行緒環境下也伴隨著諸如資料競爭（data races）等問題。Rust 語言透過其獨特的所有權模型（ownership model）和同步原語（synchronization primitives），為開發者提供了編寫安全、平行程式的強大工具。
使用 Mutex 和 Arc 實作執行緒安全
在多執行緒環境下，若多個執行緒需要分享並修改某個資料，就需要使用同步機制來避免資料競爭。Rust 中的 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..5 {
let counter_ref = Arc::clone(&counter);
let handle = thread::spawn(move || {
// 對計數器加鎖並遞增
let mut num = counter_ref.lock().unwrap();
*num += 1;
});
handles.push(handle);
}
// 等待所有執行緒完成
for handle in handles {
handle.join().unwrap();
}
// 列印最終計數器的值
println!("最終計數器值: {}", *counter.lock().unwrap());
}
內容解密：
Arc（原子參照計數）：用於在多個執行緒之間分享counter變數。Arc提供了執行緒安全的分享所有權。Mutex（互斥鎖）：用於保護counter變數，確保在同一時間內只有一個執行緒能夠修改它。lock().unwrap()：取得Mutex的鎖，允許當前執行緒存取內部資料。如果鎖被其他執行緒佔用，呼叫將被阻塞，直到鎖可用。*num += 1：對鎖定的計數器進行遞增操作。
處理執行緒終止與 Join
在多執行緒程式設計中，確保所有執行緒完成其任務後主執行緒再繼續或離開是非常重要的。Rust 提供了 join 方法來等待一個執行緒完成其執行並與之同步。
use std::thread;
use std::time;
fn main() {
let handle = thread::spawn(|| {
println!("子執行緒開始");
for i in 1..=5 {
println!("計數: {}", i);
thread::sleep(time::Duration::from_millis(1000));
}
println!("子執行緒結束");
});
// 等待子執行緒完成
handle.join().unwrap();
println!("主執行緒結束");
}
內容解密：
thread::spawn：建立一個新的執行緒並執行給定的閉包。handle.join().unwrap()：等待子執行緒完成其任務。主執行緒會被阻塞，直到子執行緒結束。
訊息傳遞平行（Message-Passing Concurrency）
Rust 中的 std::sync::mpsc 模組提供了訊息傳遞平行的支援，透過通道（channel）實作執行緒間的安全通訊。
use std::sync::mpsc;
use std::thread;
fn main() {
let (sender, receiver) = mpsc::channel();
// 建立兩個執行緒並傳送訊息
for i in 0..2 {
let sender_clone = sender.clone();
thread::spawn(move || {
sender_clone.send(i).unwrap();
});
}
// 在主執行緒接收訊息
for _ in 0..2 {
let received_message = receiver.recv().unwrap();
println!("接收到: {}", received_message);
}
}
內容解密：
mpsc::channel()：建立一個通道，傳回Sender和Receiver。sender.send(i).unwrap()：透過通道傳送訊息。receiver.recv().unwrap()：從通道接收訊息。
圖表說明
@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultTextAlignment center
skinparam rectangleBackgroundColor #F5F5F5
skinparam rectangleBorderColor #333333
skinparam arrowColor #333333
title 圖表說明
rectangle "建立通道" as node1
rectangle "傳送訊息" as node2
rectangle "接收訊息" as node3
node1 --> node2
node2 --> node3
@enduml
圖表翻譯： 此圖展示了主執行緒如何建立通道，並透過 Sender 向多個子執行緒傳送訊息，而子執行緒則將訊息傳回給主執行緒的 Receiver。