Rust 並發程式設計原子操作與記憶體排序

Rust 作為一門現代系統程式語言，在平行程式設計方面提供了強大的支援。本文將探討 Rust 中的原子操作和記憶體排序，這兩個關鍵概念對於理解和應用平行程式設計至關重要。從基本的執行緒管理、互斥鎖的使用，到更進階的原子型別操作和記憶體排序模型，本文將逐步引導讀者掌握 Rust 並發程式設計的核心技術。透過實作自定義旋轉鎖和通道等實際案例，讀者可以更深入地理解這些概念的應用，並提升自身在 Rust 平行程式設計方面的實戰能力。

Rust 並發程式設計：原子操作與記憶體排序深度解析

隨著系統程式設計變得越來越普及，Rust 語言在其中扮演了重要角色。然而，底層並發主題如原子操作和記憶體排序仍然是少數專家才能掌握的神秘領域。本文旨在填補這一知識空白，從 Rust 的角度出發，探討並發程式設計的底層原理與實踐。

本文讀者物件

本文主要針對希望深入瞭解底層並發的 Rust 開發者。同時，也適合那些對 Rust 不太熟悉但希望從 Rust 的角度瞭解並發程式設計的讀者。閱讀本文需要具備基本的 Rust 知識，並熟悉使用 Cargo 編譯和執行 Rust 程式碼。

章節概覽

本文共包含十個章節，以下是各章節的詳細介紹和預期內容：

第一章：Rust 並發基礎

本章介紹 Rust 中並發程式設計的基本工具和概念，包括執行緒、互斥鎖、執行緒安全、分享與獨佔參照、內部可變性等。這些是理解本文後續內容的基礎。對於熟悉這些概念的 Rust 程式設計師，本章可作為快速複習；對於熟悉這些概念但不熟悉 Rust 的讀者，本章將補充必要的 Rust 知識。

第二章：原子操作

第二章將探討 Rust 的原子型別及其操作。我們將從簡單的載入和儲存操作開始，逐步深入到更複雜的比較交換迴圈，並透過多個真實世界的範例來說明每個新概念。雖然記憶體排序對於每種原子操作都很重要，但本章主要關注那些可以使用放鬆記憶體排序的情況，這在實際應用中比預期更為常見。

第三章：記憶體排序

在瞭解各種原子操作及其使用方法後，第三章將介紹本文中最複雜的主題：記憶體排序。我們將探討記憶體模型的工作原理、happens-before 關係的概念及其建立方法、不同記憶體排序的意義，以及為什麼順序一致的排序並非萬能解決方案。

第四章：實作自定義旋轉鎖

在學習理論之後，接下來的三章將透過實作幾個常見的並發原語來將理論付諸實踐。第四章將實作一個自定義的旋轉鎖。我們將從一個非常基礎的版本開始，實踐 release 和 acquire 記憶體排序，然後利用 Rust 的安全性概念，將其轉變為一個易用且難以誤用的 Rust 資料型別。

第五章：實作自定義通道

在第五章中，我們將從零開始實作幾種不同版本的一次性通道（one-shot channel），這是一種可以用於在執行緒之間傳遞資料的並發原語。

為什麼閱讀本文？

無論您是希望擴充套件 Rust 並發程式設計技能、深入瞭解並發程式設計原理，還是希望改進現有的非 Rust 環境，本文都將為您提供寶貴的知識和見解。透過本文，您將能夠建立自己的正確、安全且高效的並發原語，並具備足夠的底層硬體和作業系統知識，以便做出設計決策和基本的效能最佳化權衡。

程式碼範例與解析

以下是一個簡單的原子操作範例，示範如何使用 Rust 的原子型別進行執行緒間的資料交換：

use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(AtomicUsize::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::Relaxed);
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Final counter value: {}", counter.load(Ordering::SeqCst));
}

內容解密：

1. 我們使用 Arc（原子參考計數）來分享 AtomicUsize 變數 counter，使其可以在多個執行緒間分享。
2. AtomicUsize 是一種執行緒安全的無鎖整數型別，可以進行原子操作。
3. 在每個執行緒中，我們使用 fetch_add 方法對 counter 進行原子加一操作，Ordering::Relaxed 表示使用放鬆記憶體排序，這在某些情況下可以提高效能，但不保證跨執行緒的操作順序。
4. 主執行緒等待所有子執行緒完成後，使用 load 方法讀取 counter 的最終值，並列印出來。Ordering::SeqCst 表示使用順序一致的記憶體排序，這是一種較強的記憶體排序保證，可以確保跨執行緒的操作順序一致。

圖表說明

  graph LR
    A[開始] --> B[建立執行緒]
    B --> C[執行緒間分享資料]
    C --> D[原子操作更新資料]
    D --> E[主執行緒等待所有子執行緒完成]
    E --> F[列印最終結果]

圖表翻譯： 此圖示展示了一個並發程式執行的流程。首先，程式開始並建立多個執行緒。這些執行緒分享某些資料，並透過原子操作更新這些資料。主執行緒等待所有子執行緒完成後，再列印最終結果。這個流程展示了並發程式設計中執行緒間的互動和同步機制。

Rust 並發程式設計基礎

在多核心處理器普及之前，作業系統已經能夠透過快速切換行程，讓單一電腦執行多個程式。這種方式讓每個程式都能逐步推進，輪流執行。如今，幾乎所有電腦、手機和智慧手錶都具備多核心處理器，能夠真正平行執行多個行程。

作業系統的行程隔離

作業系統盡可能地將不同行程隔離開來，讓程式在執行時無需理會其他行程的活動。例如，一個行程通常無法直接存取其他行程的記憶體，或是與其進行任何形式的通訊，除非先請求作業系統核心的允許。

執行緒分享記憶體

然而，一個程式可以建立額外的執行緒，這些執行緒屬於同一個行程的一部分。同一行程內的執行緒並未被隔離，它們分享記憶體並能透過該記憶體進行互動。

本章重點

本章將介紹如何在 Rust 中建立執行緒，以及圍繞執行緒的基本概念，例如如何在多執行緒之間安全地分享資料。這些概念是本文後續章節的基礎。

執行緒生成與基本概念

若您已熟悉 Rust 的這些部分，可以直接跳過。然而，在繼續閱讀後續章節之前，請確保您對執行緒、內部可變性、Send 和 Sync 特性，以及互斥鎖（mutex）、條件變數（condition variable）和執行緒暫停（thread parking）等概念有深入的瞭解。

Rust 並發程式設計入門

並發程式設計是現代軟體開發中的重要課題，Rust 語言透過其獨特的所有權系統和型別系統，為並發程式設計提供了堅實的基礎。本章節將從基礎開始，逐步探討 Rust 中的並發程式設計。

為何需要並發程式設計？

隨著多核心處理器的普及，如何有效地利用多核心資源，已經成為提升程式效能的關鍵。並發程式設計允許程式同時執行多個任務，充分利用系統資源，從而提升整體效能。

Rust 中的執行緒

Rust 中的執行緒允許程式平行執行多個任務。透過 std::thread 模組，開發者可以輕鬆地建立和管理執行緒。

use std::thread;
use std::time::Duration;

fn main() {
    thread::spawn(|| {
        for i in 1..10 {
            println!("計數: {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    thread::spawn(|| {
        for c in ['a', 'b', 'c', 'd', 'e'] {
            println!("字元: {}", c);
            thread::sleep(Duration::from_millis(1));
        }
    });

    // 讓主執行緒暫停足夠長的時間，以等待其他執行緒完成
    thread::sleep(Duration::from_secs(1));
}

內容解密：

上述程式碼展示瞭如何在 Rust 中建立兩個執行緒。第一個執行緒列印數字 1 到 9，第二個執行緒列印字元 ‘a’ 到 ’e’。兩個執行緒幾乎同時啟動，並透過 thread::sleep 函式進行簡單的同步，模擬耗時操作。

資料分享與同步

在並發程式設計中，資料分享是一個常見的需求。然而，多執行緒存取分享資料可能會導致資料競爭（data race），進而引發程式錯誤。Rust 透過其所有權系統和借用檢查器，在編譯階段就能夠避免大部分的資料競爭問題。

使用 Mutex 進行資料分享

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..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());
}

內容解密：

這段程式碼建立了一個包含 Mutex 的 Arc（原子參考計數），並將其複製到 10 個執行緒中。每個執行緒將分享的計數器加一。最後，主執行緒等待所有執行緒完成，並列印最終結果。

並發程式設計的最佳實踐

1. 避免資料競爭：使用 Mutex、RwLock 等同步原語來保護分享資料。
2. 使用無鎖資料結構：在某些情況下，無鎖資料結構能夠提供更好的效能。
3. 最小化鎖的持有時間：減少鎖的持有時間，可以降低死鎖的風險，並提升程式的並發效能。

Rust 中的執行緒基礎

在Rust程式設計中，執行緒（Thread）是實作平行處理的基本單位。每個程式在啟動時都會自動建立一個主執行緒（Main Thread），並執行main函式。開發者可以根據需要使用std::thread::spawn函式建立額外的執行緒。

建立執行緒

使用std::thread::spawn函式可以建立新的執行緒。該函式接受一個閉包（Closure）或函式作為引數，並在新執行緒中執行。

use std::thread;

fn main() {
    thread::spawn(|| {
        println!("Hello from another thread!");
        let id = thread::current().id();
        println!("This is my thread id: {:?}", id);
    });

    println!("Hello from the main thread.");
}

內容解密：

1. thread::spawn用於建立新的執行緒。
2. 新執行緒執行傳入的閉包內容，包括列印訊息和取得執行緒ID。
3. 主執行緒繼續執行其後續程式碼，列印主執行緒的訊息。

執行緒ID

Rust的標準函式庫為每個執行緒分配一個唯一的識別碼（ThreadId）。可以透過Thread::id()方法取得。

let id = thread::current().id();
println!("This is my thread id: {:?}", id);

內容解密：

1. thread::current().id()用於取得當前執行緒的ID。
2. ThreadId型別用於表示執行緒的唯一識別碼。

執行緒同步

當主執行緒結束時，整個程式會終止，即使其他執行緒尚未完成執行。為確保執行緒完成任務，可以使用JoinHandle的join方法等待執行緒結束。

fn main() {
    let handle = thread::spawn(|| {
        println!("Hello from another thread!");
    });

    println!("Hello from the main thread.");
    handle.join().unwrap();
}

內容解密：

1. thread::spawn傳回一個JoinHandle，用於等待執行緒結束。
2. handle.join().unwrap()用於等待執行緒完成，並處理可能的錯誤。

輸出鎖定

println!宏使用std::io::Stdout::lock()確保輸出不會被中斷。這樣可以避免多個執行緒同時輸出導致的混亂。

println!("Hello from another thread!");

內容解密：

1. println!宏確保輸出操作的原子性。
2. 多執行緒環境下，輸出內容不會被其他執行緒打斷。

閉包與所有權轉移

在建立執行緒時，通常使用閉包捕捉外部變數。為確保執行緒安全，可以使用move關鍵字將變數的所有權轉移到閉包中。

let numbers = vec![1, 2, 3];
thread::spawn(move || {
    for n in numbers {
        println!("{}", n);
    }
}).join().unwrap();

內容解密：

1. move關鍵字將numbers向量所有權轉移到閉包中。
2. 避免了因多執行緒存取同一變數導致的編譯錯誤。

從執行緒取得傳回值

可以透過閉包的傳回值，將結果傳回給主執行緒。

let numbers = vec![1, 2, 3];
let handle = thread::spawn(move || {
    let sum = numbers.into_iter().sum::<i32>();
    sum
});

let result = handle.join().unwrap();
println!("Sum: {}", result);

內容解密：

1. 閉包計算向量的和並傳回結果。
2. join方法取得執行緒的傳回值。

執行緒建構器

std::thread::Builder提供更靈活的執行緒建立方式，可以設定執行緒的堆積疊大小和名稱。

use std::thread;

fn main() {
    let builder = thread::Builder::new()
        .name("my_thread".to_string())
        .stack_size(1024 * 1024);

    let handle = builder.spawn(|| {
        println!("Hello from named thread!");
    }).unwrap();

    handle.join().unwrap();
}

內容解密：

1. thread::Builder::new()建立一個新的執行緒建構器。
2. 可以設定執行緒的名稱和堆積疊大小。

作用域執行緒

std::thread::scope函式允許建立作用域執行緒，這些執行緒保證在特定作用域內結束，避免了生命週期問題。

thread::scope(|s| {
    let numbers = vec![1, 2, 3];
    s.spawn(|| {
        println!("Length: {}", numbers.len());
    });
});

內容解密：

1. thread::scope建立一個作用域執行緒。
2. 執行緒可以安全地借用作用域內的變數。

Rust 平行程式設計基礎

緒論

Rust 語言在平行程式設計領域中提供了一套完整的工具與安全機制。本章節將探討 Rust 在平行程式設計中的基礎概念，包括執行緒的建立、資料分享以及所有權機制。

作用域執行緒（Scoped Threads）

Rust 提供了一種稱為作用域執行緒（scoped threads）的機制，允許我們在一個明確的作用域內建立執行緒，並確保這些執行緒在作用域結束前完成。

thread::scope(|s| {
    s.spawn(|| println!("Hello from a scoped thread!"));
});

內容解密：

1. thread::scope 函式接受一個閉包（closure），並在其中建立一個執行緒作用域。
2. s.spawn 用於在該作用域內建立新的執行緒。
3. 作用域執行緒保證在作用域結束時，所有尚未完成的執行緒都會被自動加入（join），確保執行緒安全。

資料分享與所有權

在平行程式設計中，資料分享是一個重要的議題。Rust 提供了多種方式來處理資料分享，包括靜態變數、記憶體洩漏（leaking）以及參考計數（reference counting）。

靜態變數

靜態變數是一種在程式執行期間始終存在的資料，可以被多個執行緒分享。

static X: [i32; 3] = [1, 2, 3];
thread::spawn(|| dbg!(&X));
thread::spawn(|| dbg!(&X));

內容解密：

1. 靜態變數 X 在程式啟動前就已經存在，並且在整個程式執行期間保持不變。
2. 多個執行緒可以安全地借用（borrow）靜態變數，因為它的生命週期是 'static。

記憶體洩漏（Leaking）

Rust 允許透過 Box::leak 將一個 Box 的所有權釋放，使其變成一個具有 'static 生命週期的參考。

let x: &'static [i32; 3] = Box::leak(Box::new([1, 2, 3]));
thread::spawn(move || dbg!(x));
thread::spawn(move || dbg!(x));

內容解密：

1. Box::leak 將 Box 的內容轉換為一個靜態參考，允許其被多個執行緒分享。
2. 雖然看起來像是將所有權移動到執行緒中，但實際上只是分享了一個參考。
3. 注意，Box::leak 會導致記憶體洩漏，因為被洩漏的記憶體永遠不會被釋放。

參考計數（Reference Counting）

為了確保分享資料在不再被使用時能夠被正確釋放，Rust 提供了 std::rc::Rc 型別來實作參考計數。

use std::rc::Rc;
let data = Rc::new(vec![1, 2, 3]);
let data_clone = Rc::clone(&data);

內容解密：

1. Rc 允許多個所有者分享同一個資料，並透過計數來決定何時釋放資料。
2. 當 Rc 的計數歸零時，資料會被自動釋放，避免了記憶體洩漏。

歷史背景：The Leakpocalypse

在 Rust 1.0 之前，標準函式庫中曾經有一個名為 std::thread::scoped 的函式，它允許非 'static 的捕捉（capture）。然而，在 Rust 1.0 發布前夕，人們發現這種設計無法保證安全性，因為物件可能不會被正確丟棄（drop）。最終，這個函式被移除，取而代之的是新的 std::thread::scope 設計。

隨著 Rust 語言的不斷進化，我們可以預期會有更多高效且安全的平行程式設計工具被加入到標準函式庫中。開發者應持續關注 Rust 的最新發展，以充分利用這些新工具來提升程式的平行處理能力。