在 Rust 的多執行緒環境中，編譯器嚴格執行所有權和借用規則，確保記憶體安全。當執行緒嘗試存取超出其生命週期的變數時，會導致編譯錯誤。常見的錯誤情境包含線上程閉包中使用外部變數，如果未正確處理所有權轉移，編譯器將提示變數的生命週期不足以支撐執行緒的執行。
Rust 提供 move 關鍵字來解決這個問題。move 關鍵字強制將變數的所有權轉移到閉包內，使閉包擁有變數的生命週期控制權，從而避免跨執行緒存取失效的記憶體區域。對於需要在多個執行緒間分享的變數，則可以透過 std::sync 模組提供的 Arc (原子參照計數) 和 Mutex (互斥鎖) 來實作。Arc 允許多個執行緒持有變數的分享所有權，Mutex 則確保同一時間只有一個執行緒可以修改分享變數，防止資料競爭。這些機制共同保障了 Rust 多執行緒程式碼的記憶體安全性和執行緒安全。
例子程式碼
use std::thread;
use std::time::Duration;
fn main() {
let pause = Duration::from_millis(100);
let handle1 = thread::spawn(move || {
thread::sleep(pause);
});
let handle2 = thread::spawn(move || {
thread::sleep(pause);
});
handle1.join().unwrap();
handle2.join().unwrap();
}
錯誤訊息與解釋
當我們嘗試編譯這個程式碼時，Rust 編譯器會報出一個錯誤：
error[E0373]: closure may outlive the current function, but it borrows `pause`, which is owned by the current function
--> src/main.rs:5:33
|
5 | let handle1 = thread::spawn(|| {
| ^^ may outlive borrowed value `pause`
6 | thread::sleep(pause);
| ----- `pause` is borrowed here
|
= note: `pause` is borrowed by the closure, but it is owned by the current function
這個錯誤訊息告訴我們， closure（匿名函式）可能會比當前函式存活更久，但它卻借用了 pause 這個變數，而 pause 是由當前函式所擁有的。
解決方案
為瞭解決這個問題，我們需要確保 pause 的生命週期至少與 closure 的生命週期一樣長。一個簡單的方法是使用 move 關鍵字將 pause 移入 closure 中，這樣 closure 就會擁有 pause，而不再只是借用它。
let handle1 = thread::spawn(move || {
thread::sleep(pause);
});
透過這個修改，closure 現在擁有了 pause，因此它的生命週期至少與 closure 相同，解決了生命週期的問題。
解決 Rust 多執行緒中變數所有權問題
在 Rust 中，當你嘗試在多個執行緒中分享變數時，編譯器會檢查變數的所有權和借用規則，以確保記憶體安全。下面是如何解決上述錯誤的步驟：
使用 move 關鍵字
當你使用 thread::spawn 建立一個新執行緒時， closure（閉包）會捕捉其環境中的變數。如果你想要將變數的所有權轉移到新執行緒中，可以使用 move 關鍵字。
let handle1 = thread::spawn(move || {
thread::sleep(pause);
});
這樣，pause 變數的所有權就會被轉移到新執行緒中，避免了所有權問題。
使用 Arc 來分享變數
如果你想要在多個執行緒中分享變數，可以使用 Arc（原子參照計數）來實作。
use std::sync::{Arc, Mutex};
use std::thread;
let pause = Arc::new(Mutex::new(1000));
let handle1 = thread::spawn({
let pause = Arc::clone(&pause);
move || {
let pause = pause.lock().unwrap();
thread::sleep(*pause);
}
});
let handle2 = thread::spawn({
let pause = Arc::clone(&pause);
move || {
let pause = pause.lock().unwrap();
thread::sleep(*pause);
}
});
在這個例子中，pause 變數被包裝在 Arc 和 Mutex 中，以便多個執行緒可以安全地分享它。
解決 Rust 多執行緒中暫停問題
在 Rust 中，當您嘗試在多執行緒環境中使用暫停（pause）變數時，可能會遇到編譯錯誤。這是因為 Rust 的所有權系統和借用檢查機制。
問題分析
在給定的程式碼中，pause 變數被宣告在 main 函式中，並試圖在兩個不同的執行緒中使用。然而，由於 Rust 的所有權規則，pause 變數不能被多個執行緒同時存取。
解決方案
為瞭解決這個問題，您需要使用 move 關鍵字將 pause 變數的所有權轉移到新的執行緒中。這樣，新的執行緒就可以獨立地存取 pause 變數，而不會與其他執行緒發生衝突。
以下是修改後的程式碼：
use std::{thread, time};
fn main() {
let pause = time::Duration::from_millis(20);
let handle1 = thread::spawn(move || {
thread::sleep(pause);
});
//...
}
在這個例子中，move 關鍵字被新增到 closure 中，以將 pause 變數的所有權轉移到新的執行緒中。這樣，新的執行緒就可以獨立地存取 pause 變數，而不會與其他執行緒發生衝突。
內容解密：
thread::spawn函式用於建立新的執行緒。move關鍵字用於將變數的所有權轉移到新的執行緒中。thread::sleep函式用於暫停執行緒的執行。
圖表翻譯：
flowchart TD
A[主執行緒] -->|建立新執行緒|> B[新執行緒]
B -->|移動變數所有權|> C[新執行緒內]
C -->|暫停執行|> D[暫停]
D -->|還原執行|> E[還原]
在這個圖表中，主執行緒建立了一個新的執行緒，並將變數的所有權轉移到新的執行緒中。新的執行緒暫停了自己的執行，然後還原了執行。
平行處理與閉包
在 Rust 中，閉包（closure）是一種特殊的函式，可以捕捉其環境中的變數，並在執行時使用它們。下面是一個簡單的例子，展示瞭如何使用閉包來實作平行處理：
use std::thread;
fn main() {
let pause = std::time::Duration::from_millis(100);
let handle1 = thread::spawn(move || {
thread::sleep(pause);
});
let handle2 = thread::spawn(move || {
thread::sleep(pause);
});
handle1.join();
handle2.join();
}
在這個例子中，我們使用 thread::spawn 函式來建立兩個新的執行緒，每個執行緒都執行一個閉包。閉包中使用 thread::sleep 函式來暫停執行緒一段時間。
閉包與函式的差異
雖然閉包和函式看起來相似，但它們之間存在一些差異。閉包是匿名的結構體，它們實作了 std::ops::FnOnce 特徵，可能還實作了 std::ops::Fn 和 std::ops::FnMut 特徵。函式則是實作為函式指標，指向可執行的程式碼。
以下是使用變數在多個閉包中的例子：
let x = 10;
let closure1 = move || {
println!("x: {}", x);
};
let closure2 = move || {
println!("x: {}", x);
};
在這個例子中，兩個閉包都捕捉了 x 變數，並在執行時使用它們。
程式生成的頭像
現在，我們來看一個更實際的應用。假設我們想要為使用者生成唯一的圖片頭像。一個方法是使用使用者名稱和雜湊函式的摘要作為引數輸入到程式生成邏輯中。這樣，每個使用者都會有視覺上相似的但完全不同的預設頭像。
我們的應用程式建立了平行線條。它透過使用使用者名稱和雜湊函式的摘要作為引數輸入到程式生成邏輯中來實作這一點。
強制編譯器顯示閉包型別
閉包的具體型別在原始碼中是不可存取的。編譯器建立了它。要檢索它，可以強制編譯器錯誤，如下所示：
fn main() {
let closure = || {
println!("Hello, world!");
};
let _ = closure as fn(); // 這會導致編譯器錯誤
}
這會導致編譯器錯誤，並顯示閉包的具體型別。
圖表翻譯：
graph LR
A[建立閉包] --> B[捕捉變數]
B --> C[執行閉包]
C --> D[使用變數]
D --> E[傳回結果]
這個圖表展示了閉包的生命週期，從建立到執行，然後使用變數並傳回結果。
瞭解 Rust 中的閉包（Closures）和型別系統
在 Rust 中，閉包（Closures）是一種特殊的函式，它可以捕捉其周圍環境中的變數。閉包的型別是編譯時期確定的，這意味著 Rust 編譯器需要知道閉包的具體型別，以便進行型別檢查。
閉包的定義和使用
下面的例子展示瞭如何定義和使用一個閉包：
let a = 20;
let add_to_a = |b| { a + b };
在這個例子中，add_to_a 是一個閉包，它捕捉了變數 a 的值，並定義了一個函式，該函式將 a 和引數 b 相加。
閉包的型別
閉包的型別是由編譯器自動推斷的。然而，在某些情況下，編譯器可能無法推斷出閉包的型別，這時候就需要顯式地指定閉包的型別。
閉包與 == 運算子
在 Rust 中，== 運算子用於比較兩個值是否相等。然而，當試圖將一個閉包與另一個值進行比較時，編譯器會報錯，因為閉包的型別不是一個簡單的值。
閉包的呼叫
要呼叫一個閉包，需要使用呼叫運算子 ()，並傳入所需的引數。例如：
let result = add_to_a(10);
這會將 add_to_a 閉包呼叫，並傳入引數 10，然後傳回結果。
閉包與變數捕捉
閉包可以捕捉其周圍環境中的變數。例如：
let a = 20;
let add_to_a = |b| { a + b };
在這個例子中，add_to_a 閉包捕捉了變數 a 的值，並使用它來計算結果。
內容解密：
在上面的例子中，我們定義了一個閉包 add_to_a，它捕捉了變數 a 的值，並定義了一個函式，該函式將 a 和引數 b 相加。然後，我們試圖將這個閉包與另一個值進行比較，結果編譯器報錯了。這是因為閉包的型別不是一個簡單的值，而是一個函式。要呼叫這個閉包，需要使用呼叫運算子 ()，並傳入所需的引數。
圖表翻譯：
flowchart TD
A[定義閉包] --> B[捕捉變數]
B --> C[定義函式]
C --> D[呼叫閉包]
D --> E[傳回結果]
這個圖表展示了閉包的工作原理，從定義閉包到呼叫閉包並傳回結果。
執行 render-hex 專案及其預期輸出
在本文中，我們將建立三個變體，並以相同的方式呼叫它們。以下清單展示了這一過程，並顯示了呼叫 render-hex 專案的輸出（清單 10.18）：
$ cd rust-in-action/ch10/ch10-render-hex
$ cargo run -- $(
> echo 'Rust in Action' |
> sha1sum |
> cut -f1 -d' '
)
呼叫後，生成了一個 SVG 檔案，內容如下：
<svg height="400" style='style="outline: 5px solid #800000;"'
<rect fill="#ffffff" height="400" width="400" x="0" y="0"/>
<path d="M200,200 L200,400 L200,400 L200,400 L200,400 L200,400 L200,
400 L480,400 L120,400 L-80,400 L560,400 L40,400 L40,400 L40,400 L40,
400 L40,360 L200,200 L200,200 L200,200 L200,200 L200,200 L200,560 L200,
-160 L200,200 L200,200 L400,200 L400,200 L400,0 L400,0 L400,0 L400,0 L80,
0 L-160,0 L520,0 L200,0 L200,0 L520,0 L-160,0 L240,0 L440,0 L200,0"
fill="none" stroke="#2f2f2f" stroke-opacity="0.9" stroke-width="5"/>
<rect fill="#ffffff" fill-opacity="0.0" height="400" stroke="#cccccc"
stroke-width="15" width="400" x="0" y="0"/>
</svg>
任何有效的 Base 16 位元組流都會生成一個唯一的影像。從 echo 'Rust in Action' | sha256sum 命令生成的 SVG 檔案渲染結果如圖 10.4 所示。要渲染 SVG 檔案，可以在網頁瀏覽器或向量影像程式（如 Inkscape）中開啟檔案。
單執行緒 render-hex 概述
render-hex 專案將輸入轉換為 SVG 檔案。SVG 檔案格式使用數學運算來描述繪圖，可以在任何網頁瀏覽器和許多圖形包中檢視。目前，該程式與多執行緒關係不大，因此我將省略許多細節。該程式由四個步驟組成的簡單管道：
- 從 STDIN 接收輸入
- 將輸入解析為描述筆在紙上移動的操作
- 將移動操作轉換為其 SVG 等效形式
- 生成 SVG 檔案
生成一些輸入以進行測試。
程式設計與SVG生成
在程式設計中，經常需要根據輸入資料生成對應的檔案名稱。這個過程可以透過多種方式實作，包括使用特定的字母表（如Base 16字母表）來建立檔案名稱。
根據輸入資料的檔案名稱生成
當我們需要根據輸入資料生成檔案名稱時，可以使用特定的字母表來實作。例如，使用0-9和A-F這16個字元來組成檔案名稱。這種方法可以確保生成的檔案名稱唯一且有意義。
多步驟處理過程
在某些情況下，直接從輸入資料生成路徑資料可能不是最好的方法。將這個過程分成兩個步驟可以允許更多的轉換和處理。這種管道式的處理方式可以在主函式中實作。
主函式實作
以下是主函式的實作範例（清單10.18）：
fn main() {
// 收集命令列引數
let args = env::args().collect::<Vec<String>>();
// 取得輸入資料
let input = args.get(1).unwrap();
// 設定預設輸出檔案名稱
let default = format!("{}.svg", input);
let save_to = args.get(2).unwrap_or(&default);
// 解析輸入資料
let operations = parse(input);
// 轉換為路徑資料
let path_data = convert(&operations);
// 生成SVG檔案
let document = generate_svg(path_data);
// 儲存SVG檔案
svg::save(save_to, &document).unwrap();
}
這個主函式負責解析命令列引數、管理SVG生成管道，並最終儲存生成的SVG檔案。
內容解密：
env::args().collect::<Vec<String>>()：收集命令列引數並轉換為字串向量。args.get(1).unwrap()：取得輸入資料。format!("{}.svg", input)：設定預設輸出檔案名稱。parse(input)：解析輸入資料。convert(&operations)：轉換為路徑資料。generate_svg(path_data)：生成SVG檔案。svg::save(save_to, &document).unwrap()：儲存SVG檔案。
圖表翻譯：
flowchart TD
A[開始] --> B[收集命令列引數]
B --> C[解析輸入資料]
C --> D[轉換為路徑資料]
D --> E[生成SVG檔案]
E --> F[儲存SVG檔案]
這個流程圖描述了主函式的執行流程，從收集命令列引數到儲存SVG檔案。
虛擬筆的指令解析
在本文中，我們的任務是將十六進位制數字轉換為虛擬筆的指令，該筆可以在畫布上移動。Operation 列舉（如下所示）代表了這些指令。
#[derive(Debug, Clone, Copy)]
enum Operation {
Forward(isize),
TurnLeft,
TurnRight,
Home,
Noop(usize),
}
為瞭解析這段程式碼，我們需要將每個位元組視為獨立的指令。數字被轉換為距離，而字母則改變繪圖的方向：
fn parse(input: &str) -> Vec<Operation> {
let mut steps = Vec::<Operation>::new();
//...
}
內容解密：
在上面的程式碼中，我們定義了一個 Operation 列舉，代表了虛擬筆的指令。這些指令包括向前移動、向左轉、向右轉、回到起點和無操作（Noop）。parse 函式的目的是將輸入字串轉換為一系列的 Operation 指令。
圖表翻譯：
flowchart TD
A[輸入字串] --> B[解析]
B --> C[生成Operation指令]
C --> D[繪圖]
在這個流程圖中，我們可以看到輸入字串如何被解析成 Operation 指令，然後用於繪圖。
程式碼實作示例：
fn main() {
let input = "123";
let operations = parse(input);
for operation in operations {
match operation {
Operation::Forward(distance) => println!("向前移動 {} 單位", distance),
Operation::TurnLeft => println!("向左轉"),
Operation::TurnRight => println!("向右轉"),
Operation::Home => println!("回到起點"),
Operation::Noop(_) => println!("無操作"),
}
}
}
在這個例子中，我們使用 parse 函式將輸入字串 “123” 轉換成 Operation 指令，然後迭代執行這些指令並列印預出相應的訊息。
圖表翻譯：
flowchart TD
A[輸入字串] --> B[解析]
B --> C[生成Operation指令]
C --> D[執行指令]
D --> E[列印結果]
在這個流程圖中，我們可以看到輸入字串如何被解析成 Operation 指令，然後執行這些指令並列印預出結果。
程式碼分析：位元組輸入處理
步驟解析
for byte in input.bytes() {
let step = match byte {
b'0' => Home,
b'1'..=b'9' => {
let distance = (byte - 0x30) as isize;
Forward(distance * (HEIGHT/10))
},
b'a' | b'b' | b'c' => TurnLeft,
b'd' | b'e' | b'f' => TurnRight,
_ => Noop(byte),
};
steps.push(step);
}
內容解密：
這段程式碼負責處理輸入的位元組序列，並根據每個位元組決定下一步的操作。操作包括移動到初始位置 (Home）、向前移動一定距離 (Forward）、向左轉 (TurnLeft）、向右轉 (TurnRight)，或者無操作 (Noop)。
- 迴圈:程式碼使用
for迴圈遍歷輸入的每個位元組。 - 模式匹配:對每個位元組使用
match表示式進行模式匹配，以決定下一步的操作。- 如果位元組是
b'0'，則執行Home操作。 - 如果位元組是從
b'1'到b'9'，則計算距離並執行Forward操作。距離計算為(byte - 0x30) as isize，然後乘以(HEIGHT/10)。 - 如果位元組是
b'a'、b'b'或b'c'，則執行TurnLeft操作。 - 如果位元組是
b'd'、b'e'或b'f'，則執行TurnRight操作。 - 對於任何其他位元組，執行
Noop操作，並將位元組作為引數傳遞。
- 如果位元組是
- 步驟追加:每次匹配後，根據匹配結果決定要執行的步驟，並將這個步驟追加到
steps向量中。
圖表翻譯：
flowchart TD
A[開始] --> B[取得輸入位元組]
B --> C{位元組匹配}
C -->|b'0'| D[Home]
C -->|b'1'..b'9'| E[計算距離並Forward]
C -->|b'a'..b'c'| F[TurnLeft]
C -->|b'd'..b'f'| G[TurnRight]
C -->|其他| H[Noop]
D --> I[追加步驟到steps]
E --> I
F --> I
G --> I
H --> I
I --> J[結束]
圖表翻譯：
此Mermaid圖表描述了程式碼的流程。它從取得輸入位元組開始，然後根據位元組的值進行匹配，決定下一步的操作。每種操作都會追加相應的步驟到 steps 中，最後結束迴圈。
從虛擬筆指令到SVG影像的生成與效能最佳化
深入剖析 render-hex 專案的核心架構後，我們可以發現其精妙之處在於將 SHA-1 雜湊值轉化為虛擬筆的繪圖指令，最終生成獨特的 SVG 影像。從程式碼實作來看，專案巧妙地利用模式匹配和迭代器處理位元組輸入，並將其轉換為 Operation 列舉，清晰地表達了繪圖邏輯。透過多維效能指標的實測分析，可以發現單執行緒架構在處理少量輸入時效率很高，但在面對大量或複雜輸入時，效能瓶頸則會顯現。
與多執行緒方案相比，目前的單執行緒實作更易於理解和維護，程式碼複雜度也更低。然而，其限制在於無法充分利用多核心處理器的效能。從不同規模專案的適用性角度比較，對於小型專案或簡單影像生成任務，單執行緒方案已足夠。但若要處理大量圖片或追求更高的生成速度，則需考慮引入多執行緒架構。技術團隊應著重於解決指令解析和 SVG 生成階段的效能瓶頸，例如，可以探索使用 SIMD 指令集最佳化位元組處理效率，或採用非同步渲染策略提升 SVG 生成速度。
展望未來，隨著 Rust 語言和生態系統的發展，我們預見非同步程式設計和多執行緒模型將在影像處理領域扮演更重要的角色。考慮到 WebAssembly 的興起，將 render-hex 專案移植到瀏覽器端執行也是一個值得探索的方向。隨著生態系統日趨完善，我們預見此類別影像生成技術的應用門檻將大幅降低。玄貓認為，此專案雖功能單一，但其設計理念和程式碼結構卻值得學習，特別是對於理解 Rust 的型別系統、模式匹配和迭代器等特性，具有很高的參考價值。
