Rust 非同步程式設計與效能最佳化

– 10 分鐘閱讀

Rust 語言以其記憶體安全和高效能著稱，尤其在多執行緒和非同步程式設計方面表現出色。本文將以掃描器效能最佳化為例，探討如何結合 Rayon 的資料平行處理和 Tokio 的非同步 I/O 操作，提升程式效率。首先，我們會分析 Rust 多執行緒程式設計中的資料競爭問題，並闡述所有權和借用規則的重要性。接著，比較非同步程式設計和多執行緒的適用場景和效能差異，並探討事件迴圈機制和工作竊取演算法。最後，我們將提供程式碼範例和 Mermaid 圖表，展示如何使用 Rayon 和 Tokio 進行效能最佳化，並討論 Rust 非同步程式設計的基礎概念，如 Future 和 Stream。

Rust 多執行緒程式設計：原理與實踐

Rust 語言以其嚴格的記憶體安全機制聞名，其中對於多執行緒的支援更是其一大亮點。本章將探討 Rust 中的多執行緒程式設計，包括其背後的原理、常見問題以及實際應用。

資料競爭問題

在多執行緒環境中，最常見的問題之一就是資料競爭（Data Race）。資料競爭發生在多個執行緒同時存取同一份資料，並且至少有一個執行緒試圖修改該資料的情況下。Rust 編譯器透過嚴格的借用檢查（Borrow Checker）機制，有效地避免了資料競爭的發生。

錯誤範例：資料競爭

use std::thread;

fn main() {
    let mut my_vec: Vec<i64> = Vec::new();
    thread::spawn(|| {
        add_to_vec(&mut my_vec);
    });
    my_vec.push(34)
}

fn add_to_vec(vec: &mut Vec<i64>) {
    vec.push(42);
}

上述程式碼會導致編譯錯誤，因為 my_vec 同時被多個執行緒以可變方式借用。錯誤訊息如下：

error[E0373]: closure may outlive the current function, but it borrows `my_vec`, which is owned by the current function

解決資料競爭

為瞭解決資料競爭問題，Rust 提供了 move 關鍵字，可以將變數的所有權轉移到閉包中。然而，這樣做仍然無法解決問題，因為 my_vec 的所有權被移動到閉包後，主執行緒就無法再存取它了。

use std::thread;

fn main() {
    let mut my_vec: Vec<i64> = Vec::new();
    thread::spawn(move || {
        add_to_vec(&mut my_vec);
    });
    my_vec.push(34) // 錯誤：my_vec 的所有權已被移動
}

fn add_to_vec(vec: &mut Vec<i64>) {
    vec.push(42);
}

錯誤訊息如下：

error[E0382]: borrow of moved value: `my_vec`

資料競爭的三個原因

  1. 多個指標同時存取同一份資料。
  2. 至少有一個指標用於寫入資料。
  3. 沒有使用任何機制來同步存取資料。

所有權規則

Rust 的所有權系統是其記憶體安全的基礎。主要規則如下：

  1. 每個值都有一個所謂的擁有者。
  2. 同一時間內只能有一個擁有者。
  3. 當擁有者離開作用域時，該值將被丟棄。

參照規則

  1. 在任何給定的時間，你可以擁有任意數量的不可變參照或恰好一個可變參照。
  2. 參照必須始終有效。

其他並發問題

除了資料競爭之外，還存在其他並發問題，如死鎖（Deadlock）和競爭條件（Race Condition）。

在掃描器中新增多執行緒支援

Rust 提供了 rayon 函式庫來簡化多執行緒程式設計。rayon 是一個資料平行函式庫，讓我們可以輕鬆地將迭代器轉換為平行迭代器。

範例：使用 rayon 進行平行掃描

use rayon::prelude::*;

fn main() -> Result<()> {
    // ...
    let pool = rayon::ThreadPoolBuilder::new()
        .num_threads(256)
        .build()
        .unwrap();

    pool.install(|| {
        let scan_result: Vec<Subdomain> = subdomains::enumerate(&http_client, target)
            .unwrap()
            .into_par_iter()
            .map(ports::scan_ports)
            .collect();

        for subdomain in scan_result {
            println!("{}:", &subdomain.domain);
            for port in &subdomain.open_ports {
                println!(" {}", port.port);
            }
            println!("");
        }
    });
    // ...
}

#### 內容解密：

此範例展示瞭如何使用 rayon 建立一個自定義的執行緒池，並利用平行迭代器對子網域進行掃描。into_par_iter() 方法將迭代器轉換為平行迭代器，使得每個子網域的掃描工作可以在不同的執行緒中平行進行。

背後原理

使用 rayon 的背後原理包括：

  1. Prelude：rayon::prelude::* 匯入了多個重要的 trait 和結構體，簡化了平行程式設計的介面。

    use rayon::prelude::*;

    #### 內容解密：

    這行程式碼匯入了 rayon 所需的 trait，使得我們可以使用平行迭代器等功能。

  2. 執行緒池：rayon 在背景建立了一個執行緒池，並將任務分派給該池中的執行緒。這種設計隱藏了執行緒管理的複雜性，讓開發者可以專注於演算法設計。

    let pool = rayon::ThreadPoolBuilder::new()
    .num_threads(256)
    .build()
    .unwrap();

    #### 內容解密：

    這段程式碼建立了一個包含 256 個執行緒的自定義執行緒池，用於執行平行任務。

其他替代方案

另一個常用的多執行緒函式庫是 threadpool，它提供了更底層的控制，但需要手動建立和管理執行緒池。

use std::sync::mpsc::channel;
use threadpool::ThreadPool;

fn main() {
    let n_workers = 4;
    let n_jobs = 8;
    // ...
}

#### 內容解密：

這段程式碼展示瞭如何使用 threadpool 函式庫建立一個執行緒池，並指定工作執行緒的數量。

以非同步程式設計提升掃描器效能

在前面的章節中，我們討論瞭如何使用多執行緒技術來提高程式的執行效率。然而，多執行緒並不是提升程式效能的唯一方法，特別是在我們的案例中，大部分時間都花費在 I/O 操作（TCP 連線）上。

為什麼需要非同步程式設計

從程式設計師的角度來看，非同步程式設計（async/await）提供了與多執行緒相同的功能（平行處理、更好的硬體利用率、更快的速度），但對於 I/O 密集型的工作負載，具有更好的效能和更低的資源使用率。

I/O 密集型的工作負載是指大部分時間都花費在等待網路或磁碟操作完成的任務，而不是受限於處理器的運算能力。傳統的執行緒是為計算密集型的任務而設計的，不適合用於大量的平行 I/O 任務。

效能比較

操作非同步執行緒
建立0.3 微秒17 微秒
上下文切換0.2 微秒1.7 微秒

根據 Jim Blandy 的測量結果，非同步程式設計的上下文切換速度大約是執行緒的 8.5 倍，而且使用的記憶體約為執行緒的 1/20。

合作式與搶佔式排程

在程式設計語言的世界中，主要有兩種處理 I/O 任務的方法：搶佔式排程和合作式排程。

搶佔式排程

搶佔式排程是指任務的排程完全由執行時環境控制，開發者無法控制任務的切換。例如，Go 程式語言就採用了搶佔式排程。這種方法的優點是易於學習和使用，因為開發者不需要區分同步和非同步程式碼。然而，它的缺點是效能受限於執行時環境的智慧程度，而且難以除錯。

合作式排程

合作式排程是指開發者需要告訴執行時環境什麼時候任務會等待 I/O 操作。在 Rust 中，這是透過 await 關鍵字實作的。這種方法的優點是效能極高，因為開發者和執行時環境可以協同工作，充分利用計算資源。然而，它的缺點是容易被誤用，如果開發者忘記使用 await 或阻塞了事件迴圈，就會導致效能問題。

Rust 中的非同步程式設計

Rust 語言透過 async 和 await 關鍵字提供了對非同步程式設計的原生支援。開發者可以使用 async 定義非同步函式，並使用 await 等待非同步操作的完成。

程式碼範例

use tokio::time::{sleep, Duration};

async fn hello_world() {
    println!("Hello, ");
    sleep(Duration::from_millis(1000)).await;
    println!("World!");
}

#[tokio::main]
async fn main() {
    hello_world().await;
}

在這個範例中，hello_world 函式是一個非同步函式，它會先列印 “Hello, “，然後等待 1 秒，最後列印 “World!"。main 函式使用了 tokio::main 宏來啟動一個非同步執行時環境，並呼叫 hello_world 函式。

內容解密：

  • async fn hello_world() 定義了一個名為 hello_world 的非同步函式。
  • sleep(Duration::from_millis(1000)).await; 這行程式碼使函式等待 1 秒後再繼續執行。
  • #[tokio::main] 宏用於定義一個非同步的 main 函式，並啟動 Tokio 執行時環境。
  • hello_world().await; 這行程式碼呼叫了 hello_world 函式並等待其完成。

使用非同步程式設計最佳化掃描器

在掃描器的案例中，我們可以使用非同步程式設計來最佳化網路請求的處理。透過使用非同步 I/O 操作，我們可以同時發起多個網路請求，而不需要等待每個請求完成。這樣可以大大提高掃描器的效率和速度。

程式碼範例

use tokio::net::TcpStream;

async fn scan_port(host: &str, port: u16) -> bool {
    match TcpStream::connect(format!("{}:{}", host, port)).await {
        Ok(_) => true,
        Err(_) => false,
    }
}

#[tokio::main]
async fn main() {
    let host = "example.com";
    for port in 1..=1024 {
        if scan_port(host, port).await {
            println!("Port {} is open", port);
        }
    }
}

在這個範例中，scan_port 函式是一個非同步函式，它嘗試連線到指定的主機和埠。如果連線成功，則傳回 true，否則傳回 false。main 函式遍歷了 1 到 1024 的埠，並對每個埠呼叫 scan_port 函式。

內容解密：

  • async fn scan_port(host: &str, port: u16) -> bool 定義了一個名為 scan_port 的非同步函式，用於掃描指定的埠。
  • TcpStream::connect(format!("{}:{}", host, port)).await 這行程式碼嘗試連線到指定的主機和埠，並等待連線操作的完成。
  • 在 main 函式中，我們遍歷了 1 到 1024 的埠，並對每個埠呼叫 scan_port 函式，以檢查該埠是否開放。

Mermaid 圖表演示：掃描器工作流程

  graph LR
    E[E]
    H[H]
    A[開始掃描] --> B[解析目標主機]
    B --> C[建立非同步任務]
    C --> D[發起網路請求]
    D --> E{埠是否開放?}
    E -->|是| F[記錄開放埠]
    E -->|否| G[繼續下一個埠]
    F --> G
    G --> H{是否掃描完畢?}
    H -->|是| I[結束掃描]
    H -->|否| C

圖表翻譯：

此圖示展示了一個掃描器的工作流程。首先，掃描器開始掃描目標主機，然後解析目標主機並建立非同步任務。接著，掃描器發起網路請求，並根據埠是否開放進行不同的處理。如果埠開放，則記錄該埠；否則，繼續掃描下一個埠。這個過程會持續到所有埠都掃描完畢為止。

本篇文章討論瞭如何使用非同步程式設計來最佳化掃描器的效能，並提供了相關的程式碼範例和 Mermaid 圖表演示。透過使用非同步 I/O 操作，我們可以大大提高掃描器的效率和速度。同時，我們也介紹了 Rust 語言中的非同步程式設計模型和相關函式庫，希望能夠對讀者有所幫助。

總字數：6,045 字

隨著網路技術的不斷發展，掃描器的應用場景也在不斷擴充套件。未來，我們可以期待看到更多根據非同步程式設計的掃描器實作，以滿足日益增長的網路安全需求。同時，我們也需要不斷改進和最佳化掃描器的演算法和實作，以提高其效能和準確性。

本章節討論了使用非同步程式設計來最佳化掃描器的效能，希望能夠對讀者有所啟發和幫助。透過結合理論知識和實踐經驗，我們可以更好地理解和應用非同步程式設計技術，從而提高我們的程式設計能力和解決問題的能力。

總之，非同步程式設計是一種強大的技術，可以幫助我們編寫出更高效、更可靠的程式碼。透過學習和實踐，我們可以更好地掌握這項技術，並將其應用於實際專案中，以提高我們的開發效率和產品品質。

事件迴圈（Event Loop）與 Rust 中的非同步程式設計

在探討 Rust 的非同步程式設計之前，瞭解事件迴圈（Event Loop）的概念至關重要。事件迴圈是所有非同步執行時的基礎，包括 Rust、Node.js 等語言的非同步處理核心。

什麼是事件迴圈？

事件迴圈是一種機制，能夠有效地管理多個任務並確保系統資源的最佳利用。簡單來說，它就像是一個持續執行的迴圈，不斷檢查是否有新的任務需要處理，並將這些任務分配給可用的處理器。

事件迴圈的工作原理

在現代的非同步執行時中，通常會有多個事件迴圈，每個 CPU 核心對應一個。這種設計大大提高了系統的平行處理能力和整體效能。以 Tokio 為例，它採用了「工作竊取（Work-Stealing）」的策略。當某個處理器完成其當前任務佇列中的所有工作時，它可以從其他處理器的佇列中「竊取」任務來執行，從而最大限度地減少處理器的閒置時間。

圖示：工作竊取執行時

  graph LR
    A[CPU 核心1] -->|執行任務|> B[任務佇列1]
    C[CPU 核心2] -->|執行任務|> D[任務佇列2]
    C -->|竊取任務|> B
    A -->|竊取任務|> D
    subgraph 工作竊取執行時
        B -->|包含任務|> E[任務1, 任務2, ...]
        D -->|包含任務|> F[任務3, 任務4, ...]
    end

圖表翻譯： 此圖示呈現了一個典型的多核心工作竊取執行時的運作方式。每個 CPU 核心都有自己的任務佇列，當某個核心的佇列為空時，它可以從其他核心的佇列中竊取任務來執行。這種機制有效地提高了系統的整體效能和資源利用率。

為什麼事件迴圈如此重要？

  1. 高效的資源利用：透過非阻塞 I/O 和任務竊取機制，事件迴圈能夠充分利用系統資源，避免無謂的等待時間。
  2. 提高系統回應速度：由於事件迴圈能夠快速切換不同的任務，因此即使在處理大量並發請求時，系統仍能保持良好的回應速度。
  3. 簡化並發程式設計：事件迴圈和非同步程式設計模型大大簡化了開發者編寫並發程式的複雜度，使其能夠專注於業務邏輯而非底層執行緒管理。

Rust 中的非同步程式設計基礎

Rust 提供了一套完整的非同步程式設計工具和函式庫，其中最為重要的是 Future 和 async/await 語法糖。

Future

在 Rust 中，Future 代表一個可能尚未完成的非同步運算。它類別似於 JavaScript 中的 Promise。當你使用 .await 時，你實際上是在等待一個 Future 的完成。

async fn do_something() -> i64 {
    // 非同步運算
}
// do_something 傳回一個 Future<Output = i64>
let f = async { 1u64 };
// f 是一個 Future<Output = u64>

Streams

Streams 是非同步迭代器，用於處理一系列非同步到達的值。它們非常適合用於處理網路請求、檔案讀取等場景。

use tokio::stream::{self, StreamExt};

async fn process_stream() {
    let mut stream = stream::iter(1..10);
    while let Some(value) = stream.next().await {
        println!("Received: {}", value);
    }
}

Tokio：Rust 的非同步執行時

Tokio 是目前 Rust 社群中最流行的非同步執行時。它提供了豐富的功能，如非阻塞 I/O、定時器、TCP/UDP 支援等。

Spawning

在 Tokio 中，你可以使用 tokio::spawn 將一個非同步任務派發到執行時。這使得你的程式能夠利用多核 CPU 的優勢。

tokio::spawn(async move {
    // 非同步任務邏輯
});

Sleep 和 Timeout

Tokio 提供了 tokio::time::sleep 用於實作非阻塞的睡眠，以及 tokio::time::timeout 用於為 Future 新增超時機制。

tokio::time::sleep(Duration::from_millis(100)).await;
// 為某個 Future 新增超時
tokio::time::timeout(Duration::from_secs(3), async_operation).await?;
玄貓

玄貓

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