Rust 多執行緒效能分析：睡眠與忙等待策略比較

– 12 分鐘閱讀

在 Rust 的多執行緒環境中，有效管理執行緒的暫停和還原對於整體效能至關重要。本文將深入比較兩種常見的執行緒暫停策略：睡眠策略和忙等待（自旋鎖）策略，分析它們在不同執行緒數量下，暫停 20 毫秒的效能表現。透過實際程式碼範例和實驗結果，我們將揭示兩種策略的優劣，並探討如何根據應用場景選擇合適的策略。

執行緒

執行緒是一個輕量級的程式，它分享同一程式的記憶體空間和資源。執行緒的建立和切換比程式快，因為它們不需要建立新的記憶體空間和資源。執行緒通常用於實作多工的平行執行，例如在網頁瀏覽器中，多個執行緒可以同時執行不同的任務，如載入網頁、播放音樂等。

程式

程式是一個重量級的執行單元，它具有自己的記憶體空間和資源。程式的建立和切換比執行緒慢，因為它們需要建立新的記憶體空間和資源。程式通常用於實作多程式的平行執行，例如在作業系統中，多個程式可以同時執行不同的程式，如文字編輯器、圖片編輯器等。

執行緒與程式的比較

執行緒程式
記憶空間分享同一程式的記憶空間具有自己的記憶空間
資源分享同一程式的資源具有自己的資源
建立和切換快慢
用途多工的平行執行多程式的平行執行

實驗結果

下圖展示了使用睡眠策略和自旋鎖策略等待 20 毫秒的執行緒所需的時間。隨著執行緒數量的增加，兩種策略之間的差異變得明顯。

  flowchart TD
    A[睡眠策略] --> B[等待 20 毫秒]
    B --> C[傳回]
    D[自旋鎖策略] --> E[忙等待 20 毫秒]
    E --> F[傳回]

圖表翻譯：

上述 Mermaid 圖表展示了睡眠策略和自旋鎖策略的流程差異。睡眠策略直接等待 20 毫秒，而自旋鎖策略則忙等待 20 毫秒。這兩種策略對於等待時間的處理方式不同，導致了不同的效能結果。

執行緒效能分析：睡眠策略與忙等待策略

在多執行緒程式設計中，執行緒的暫停和還原對於系統的效能有著重要影響。這篇文章將探討睡眠策略和忙等待策略（也稱為忙迴圈或自旋迴圈）在暫停執行緒20毫秒時的效能差異。

睡眠策略

睡眠策略是透過向作業系統發出請求，要求執行緒在指定時間內暫停執行。這種策略可以有效地節省CPU資源，因為暫停的執行緒不會佔用CPU時間。以下是使用Rust語言實作的睡眠策略範例：

use std::{thread, time};

fn main() {
    let sleep_duration = time::Duration::from_millis(20);
    thread::sleep(sleep_duration);
}

在這個範例中，thread::sleep函式被用來暫停執行緒20毫秒。

忙等待策略

忙等待策略是透過使用忙迴圈（busy loop）或自旋迴圈（spin loop）來暫停執行緒。這種策略會不斷地執行一個空迴圈，直到指定時間過去。以下是使用Rust語言實作的忙等待策略範例：

use std::{thread, time};

fn main() {
    let start_time = time::Instant::now();
    while time::Instant::now().duration_since(start_time) < time::Duration::from_millis(20) {
        // 忙等待
    }
}

在這個範例中，忙等待迴圈會不斷地執行，直到20毫秒過去。

效能比較

為了比較睡眠策略和忙等待策略的效能，我們可以使用以下程式碼來生成輸入資料：

use std::{thread, time};

fn main() {
    let num_threads = 20;
    let sleep_duration = time::Duration::from_millis(20);

    for _ in 0..num_threads {
        thread::spawn(move || {
            thread::sleep(sleep_duration);
        });
    }
}

這個程式碼會建立20個執行緒，每個執行緒都會暫停20毫秒。然後，我們可以使用以下程式碼來分析輸出資料：

use std::{fs, io};

fn main() {
    let data = fs::read_to_string("output.txt").unwrap();
    let lines: Vec<&str> = data.lines().collect();

    for line in lines {
        println!("{}", line);
    }
}

這個程式碼會讀取輸出資料，並將其列印到終端。

結果

經過分析，我們可以看到睡眠策略和忙等待策略在暫停執行緒20毫秒時的效能差異。睡眠策略可以有效地節省CPU資源，而忙等待策略會不斷地佔用CPU時間。

圖表翻譯：

下圖顯示了睡眠策略和忙等待策略在暫停執行緒20毫秒時的效能差異。

  flowchart TD
    A[睡眠策略] --> B[暫停執行緒 20毫秒]
    B --> C[節省CPU資源]
    A --> D[忙等待策略]
    D --> E[不斷佔用CPU時間]

這個圖表顯示了睡眠策略和忙等待策略的效能差異。睡眠策略可以有效地節省CPU資源，而忙等待策略會不斷地佔用CPU時間。

多執行緒處理與效能最佳化

在現代軟體開發中，多執行緒處理是一種常見的技術，用於提高程式的效能和回應速度。下面是一個使用 Rust 程式語言實作的多執行緒處理範例，展示瞭如何建立和管理多個執行緒。

範例程式碼

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

fn main() {
    for n in 1..1001 {
        let mut handlers: Vec<thread::JoinHandle<()>> = Vec::with_capacity(n);
        
        let start = std::time::Instant::now();
        
        for _m in 0..n {
            let handle = thread::spawn(|| {
                let pause = Duration::from_millis(20);
                thread::sleep(pause);
            });
            
            handlers.push(handle);
        }
        
        while let Some(handle) = handlers.pop() {
            handle.join();
        }
    }
}

內容解密：

上述程式碼建立了一個主執行緒，並使用 for 迴圈建立了多個子執行緒。每個子執行緒都會暫停 20 毫秒後繼續執行。主執行緒會等待所有子執行緒完成後繼續執行。

圖表翻譯：

  flowchart TD
    A[主執行緒] --> B[建立子執行緒]
    B --> C[子執行緒暫停 20 毫秒]
    C --> D[子執行緒繼續執行]
    D --> E[主執行緒等待子執行緒完成]
    E --> F[主執行緒繼續執行]

這個範例展示瞭如何使用 Rust 的 thread 模組建立和管理多個執行緒。透過使用 thread::spawn 函式，可以建立新的執行緒，並使用 thread::JoinHandle 來等待執行緒完成。

技術選型分析：

在這個範例中，我們使用了 Rust 的 thread 模組來建立和管理多個執行緒。Rust 的 thread 模組提供了一個簡單且安全的方式來建立和管理執行緒。透過使用 thread::spawn 函式，可以建立新的執行緒，並使用 thread::JoinHandle 來等待執行緒完成。

未來趨勢：

在未來，多執行緒處理將繼續是一種重要的技術，用於提高程式的效能和回應速度。隨著硬體技術的進步，多核心處理器將成為常態，多執行緒處理將變得更加重要。

實際應用場景：

多執行緒處理可以應用於許多實際場景，例如：

  • 網路伺服器：可以使用多個執行緒來處理多個網路連線，提高伺服器的效能和回應速度。
  • 資料函式庫查詢：可以使用多個執行緒來查詢資料函式庫，提高查詢效率。
  • 科學計算：可以使用多個執行緒來進行科學計算，提高計算效率。

效能最佳化分析：

在這個範例中，我們使用了 thread::sleep 函式來暫停子執行緒 20 毫秒。這可以模擬實際應用場景中的暫停時間。透過使用 thread::JoinHandle 來等待子執行緒完成，可以確保主執行緒會等待所有子執行緒完成後繼續執行。

安全性考量：

在使用多執行緒處理時，需要考慮安全性問題。例如，需要確保多個執行緒之間的資料分享是安全的，需要避免資料競爭和死鎖等問題。Rust 的 thread 模組提供了一個安全的方式來建立和管理執行緒，透過使用 thread::spawn 函式和 thread::JoinHandle 來等待執行緒完成，可以確保資料分享是安全的。

使用 Rust 進行多執行緒程式設計

在 Rust 中，std::thread 模組提供了建立和管理執行緒的功能。以下是使用 std::thread 建立多個執行緒，並使用 thread::sleep 和 spin loop 等待策略的範例。

使用 thread::sleep 來暫停執行緒

use std::{thread, time};

fn main() {
    for n in 1..1001 {
        let mut handlers: Vec<thread::JoinHandle<()>> = Vec::with_capacity(n);
        let start = time::Instant::now();

        for _ in 0..n {
            let handle = thread::spawn(|| {
                let start = time::Instant::now();
                let pause = time::Duration::from_millis(20);

                while start.elapsed() < pause {
                    thread::yield_now();
                }
            });
            handlers.push(handle);
        }

        let finish = time::Instant::now();
        println!("{}\t{:02?}", n, finish.duration_since(start));
    }
}

使用 spin loop 等待策略

在上面的範例中，我們使用 thread::sleep 來暫停執行緒。但是，在某些情況下，spin loop 可能是一種更好的選擇。以下是使用 spin loop 等待策略的範例：

use std::{thread, time};

fn main() {
    for n in 1..1001 {
        let mut handlers: Vec<thread::JoinHandle<()>> = Vec::with_capacity(n);
        let start = time::Instant::now();

        for _ in 0..n {
            let handle = thread::spawn(|| {
                let start = time::Instant::now();
                let pause = time::Duration::from_millis(20);

                while start.elapsed() < pause {
                    // spin loop
                }
            });
            handlers.push(handle);
        }

        let finish = time::Instant::now();
        println!("{}\t{:02?}", n, finish.duration_since(start));
    }
}

比較 thread::sleep 和 spin loop

thread::sleep 和 spin loop 都可以用來暫停執行緒，但是它們有不同的特點。

  • thread::sleep 會將執行緒暫停一段時間，並且不會佔用 CPU 資源。
  • spin loop 會將執行緒暫停一段時間，但是會佔用 CPU 資源。

在一般情況下，thread::sleep 是一個更好的選擇，因為它不會佔用 CPU 資源。然而，在某些情況下，spin loop 可能是一種更好的選擇，例如當執行緒需要快速回應時。

使用Rust語言進行多執行緒處理

在Rust中，當我們需要進行多執行緒的處理時，我們可以使用std::thread模組來建立和管理執行緒。以下是一個簡單的例子，展示瞭如何建立和等待多個執行緒。

建立和等待執行緒

use std::thread;
use std::time::Instant;

fn main() {
    let n = 10;
    let mut handlers = vec![];

    let start = Instant::now();

    for _ in 0..n {
        let handle = thread::spawn(|| {
            // 執行任務的程式碼
        });
        handlers.push(handle);
    }

    while let Some(handle) = handlers.pop() {
        handle.join().unwrap();
    }

    let finish = Instant::now();
    println!("{}\t{:02?}", n, finish.duration_since(start));
}

在這個例子中，我們建立了10個執行緒，並將它們存放在handlers向量中。然後，我們使用while let迴圈來等待每個執行緒完成。這種方法可以確保所有執行緒都完成後才繼續執行主執行緒。

比較不同的控制流機制

在上面的例子中，我們使用了while let迴圈來等待執行緒完成。這種方法與使用for迴圈迭代handlers向量有所不同。以下是兩種方法的比較：

使用for迴圈

for handle in &handlers {
    handle.join().unwrap();
}

使用while let迴圈

while let Some(handle) = handlers.pop() {
    handle.join().unwrap();
}

雖然兩種方法都可以實作等待執行緒完成的功能，但使用while let迴圈可以更好地控制執行緒的執行順序。

使用更複雜的控制流機制

在某些情況下，使用更複雜的控制流機制可能是必要的。例如，在 Rust 中，當我們將一個執行緒加入到主執行緒時，它就會停止存在。Rust 不允許我們保留對不存在東西的參照。因此，要在處理器中呼叫 join() 方法，必須先將處理器從列表中移除。

這就引發了一個問題：for 迴圈不允許修改被迭代的資料。相反，while 迴圈允許我們反覆獲得可變的存取權，以便在呼叫 handlers.pop() 時移除處理器。

以下是一個使用忙等待（spin loop）策略的實作例子。這個實作是有缺陷的，因為它使用了更熟悉的 for 迴圈控制流，而不是在之前的列表中避免使用的控制流。

use std::{thread, time};

fn main() {
    for n in 1..1001 {
        let mut handlers: Vec<thread::JoinHandle<()>> = Vec::with_capacity(n);
        
        let start = time::Instant::now();
        
        for _m in 0..n {
            let handle = thread::spawn(|| {
                let start = time::Instant::now();
                let pause = time::Duration::from_millis(20);
                //...
            });
            handlers.push(handle);
        }
        
        //...
    }
}

在這個例子中，我們使用 for 迴圈來建立和啟動執行緒，並將處理器新增到列表中。然而，這個實作是有缺陷的，因為它使用了 for 迴圈，而不是 while 迴圈。

修正實作

要修正這個實作，我們需要使用 while 迴圈來迭代處理器列表，並在呼叫 join() 方法之前將處理器從列表中移除。以下是修正後的實作：

use std::{thread, time};

fn main() {
    for n in 1..1001 {
        let mut handlers: Vec<thread::JoinHandle<()>> = Vec::with_capacity(n);
        
        let start = time::Instant::now();
        
        for _m in 0..n {
            let handle = thread::spawn(|| {
                let start = time::Instant::now();
                let pause = time::Duration::from_millis(20);
                //...
            });
            handlers.push(handle);
        }
        
        while let Some(handle) = handlers.pop() {
            handle.join();
        }
    }
}

在這個修正後的實作中，我們使用 while 迴圈來迭代處理器列表，並在呼叫 join() 方法之前將處理器從列表中移除。這樣可以確保執行緒被正確地加入到主執行緒中，並且處理器列表被正確地更新。

錯誤分析與解決

錯誤訊息 error[E0507]: cannot move out of *handle which is behind a 指出問題出在嘗試移動 handle 的值，但 handle 是一個參照（behind a reference）。這是因為在 Rust 中，當你使用 & 來借用一個值時，你不能直接移動這個值，因為它仍然被參照著。

錯誤程式碼

for handle in &handlers {
    handle.join();
}

在這段程式碼中，handle 是一個參照，指向 handlers 向量中的元素。當你嘗試呼叫 join() 方法時，Rust 不允許你移動 handle 的值，因為它仍然被 &handlers 參照著。

解決方案

要解決這個問題，你需要使用 iter() 方法來迭代 handlers 向量，而不是直接借用它的參照。這樣，你就可以移動每個 handle 的值，並呼叫 join() 方法。

for handle in handlers {
    handle.join();
}

或者，你可以使用 into_iter() 方法來消耗 handlers 向量，並移動每個 handle 的值。

for handle in handlers.into_iter() {
    handle.join();
}

完整程式碼

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

fn main() {
    let mut handlers = vec![];
    let start = time::Instant::now();
    let n = 10;

    for _ in 0..n {
        let handle = thread::spawn(move || {
            while start.elapsed().as_secs() < 1 {
                thread::yield_now();
            }
        });
        handlers.push(handle);
    }

    for handle in handlers.into_iter() {
        handle.join();
    }

    let finish = time::Instant::now();
    println!("{}\t{:02?}", n, finish.duration_since(start));
}

這個程式碼會建立 10 個執行緒，每個執行緒會等待 1 秒鐘後結束。主執行緒會等待所有子執行緒結束後，才會印出執行時間。

使用 Rust 進行多執行緒程式設計

在 Rust 中，使用多執行緒可以大大提高程式的效能和反應速度。然而，多執行緒程式設計也帶來了一些挑戰，例如如何安全地分享資料和避免競爭條件。

分享資料的問題

當多個執行緒嘗試存取相同的資料時，可能會發生競爭條件。為了避免這種情況，Rust 提供了 std::thread::JoinHandle 類別，可以用來等待執行緒完成並取得其結果。

但是，當使用 JoinHandle 時，可能會遇到移動語義（move semantics）的問題。例如，在下面的程式碼中：

let handle = std::thread::spawn(|| {
    //...
});
handle.join();

編譯器會報錯，因為 handle 被移動到了 join 方法中，而不能再被使用。

解決方法

為瞭解決這個問題，可以使用迴圈直接迭代 handlers 向量，而不需要取參照：

for handle in handlers {
    handle.join();
}

這樣可以避免移動語義的問題，並且可以安全地等待所有執行緒完成。

Yielding 控制

在忙碌迴圈（busy loop）中，使用 std::thread::yield_now 函式可以將控制權交給作業系統，允許其他執行緒執行。然而，這個方法有一個缺點，就是不能保證在確切的時間點還原執行。

另一個選擇是使用 std::sync::atomic::spin_loop_hint 函式，這個函式直接與 CPU 互動，提供了一個 hint 來最佳化執行。然而，這個函式不支援所有的 CPU 平臺，如果不支援，則不會有任何作用。

內容解密：
  • 使用 std::thread::JoinHandle 類別可以安全地等待執行緒完成並取得其結果。
  • 迴圈直接迭代 handlers 向量可以避免移動語義的問題。
  • std::thread::yield_now 函式可以將控制權交給作業系統，允許其他執行緒執行。
  • std::sync::atomic::spin_loop_hint 函式直接與 CPU 互動，提供了一個 hint 來最佳化執行。

圖表翻譯：

  flowchart TD
    A[建立執行緒] --> B[等待執行緒完成]
    B --> C[取得結果]
    C --> D[處理結果]
    D --> E[結束]

這個流程圖描述了使用 std::thread::JoinHandle 類別建立執行緒、等待執行緒完成、取得結果、處理結果和結束的過程。

分享變數

在我們的多執行緒效能測試中，我們在每個執行緒中建立了暫停變數。如果你不清楚我指的是什麼，以下的程式碼片段提供了 listing 10.5 中的一個摘錄。

let handle = thread::spawn(|| {
    let start = time::Instant::now();
    let pause = time::Duration::from_millis(20);
    while start.elapsed() < pause {
        thread::yield_now();
    }
});

我們想要能夠寫出像以下的程式碼。這個程式碼來源於 ch10/ch10-sharedpause-broken/src/main.rs。

我們可以在 listing 10.5 中使用的程式碼

use std::{thread, time};

fn main() {
    let pause = time::Duration::from_millis(20);
    let handle1 = thread::spawn(|| {
        thread::sleep(pause);
    });
}

這個變數不需要在每個執行緒中都被建立。透過分享變數，我們可以避免不必要地建立 time::Duration 例項。

分享變數的優點

  • 減少不必要的計算和記憶體分配
  • 提高程式效率和效能

實作分享變數

use std::{thread, time};

fn main() {
    let pause = time::Duration::from_millis(20);
    let handle1 = thread::spawn(move || {
        thread::sleep(pause);
    });
}

在這個例子中，我們使用 move 關鍵字將 pause 變數移到新的執行緒中，這樣就可以在多個執行緒中分享這個變數。

圖表翻譯

  flowchart TD
    A[主執行緒] --> B[建立分享變數]
    B --> C[spawn 新執行緒]
    C --> D[新執行緒睡眠]
    D --> E[主執行緒繼續執行]

這個流程圖顯示了主執行緒建立分享變數、spawn 新執行緒、以及新執行緒睡眠的過程。

內容解密

在上面的程式碼中，我們使用 thread::spawn 函式建立了一個新的執行緒，並將 pause 變數移到新的執行緒中。這樣就可以在多個執行緒中分享這個變數，避免不必要地建立 time::Duration 例項。

透過分享變數，我們可以提高程式效率和效能，減少不必要的計算和記憶體分配。

平行處理與生命週期：一個關於執行緒與借用檢查的例子

在平行處理中，管理執行緒和分享資源的生命週期是一個重要的課題。下面這個例子將展示如何使用 Rust 的執行緒並發機制，並解釋一下相關的生命週期問題。

從效能最佳化視角來看，Rust 的多執行緒模型提供了一種兼顧效能和安全性的平行處理機制。本文深入探討了thread::sleep、忙等待(spin loop)以及執行緒間分享變數等策略的效能影響，並分析了for 迴圈和 while let 迴圈在控制執行緒生命週期上的差異。while let 迴圈搭配 Vec::pop() 方法，更符合 Rust 的所有權機制，避免了因移動語義導致的編譯錯誤，從而更有效地管理執行緒的生命週期。然而，忙等待策略雖然在某些特定場景下可以減少執行緒上下文切換的開銷，但其持續佔用 CPU 資源的特性也可能成為效能瓶頸。對於需要精確控制執行緒暫停時間的場景，thread::yield_now() 提供了更合理的解決方案，它允許作業系統排程其他任務，從而提高整體系統的效率。展望未來，隨著硬體的發展和 Rust 語言的演進，更精細化的執行緒控制機制和更完善的效能分析工具將會出現，進一步提升 Rust 在高併發場景下的應用潛力。對於開發者而言，深入理解 Rust 的所有權系統和生命週期管理至關重要，才能寫出既安全又高效的平行程式。技術團隊應著重於執行緒間通訊和資料同步的最佳實務，才能最大限度地發揮 Rust 多執行緒的優勢。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。