Rust 泛型與特徵物件平行處理詳解

Rust 提供了泛型和特徵等機制，讓開發者能夠編寫更具彈性、可重用性及型別安全的程式碼。本文將結合平行處理的例項，展示如何利用這些特性提升程式碼效率。在平行掃描子網域名稱案例中，buffer_unordered 和 collect 方法能有效管理和執行多個非同步任務，並控制平行度。埠掃描的平行處理則利用 tokio::spawn 生成非同步任務，並透過 for_each_concurrent 對接收到的埠號進行平行掃描。此外，單一埠掃描時，tokio::time::timeout 設定超時機制，避免無謂的等待。泛型程式設計能提高程式碼的重用性和可靠性，透過泛型函式、結構體和列舉，可以編寫適用於多種資料型別的程式碼，同時保有型別安全和效能優勢。特徵則定義了分享行為，類別似其他語言的介面，並支援預設實作，讓程式碼更具彈性。最後，特徵物件能將不同但實作共同特徵的型別儲存於同一個集合中，進一步提升程式碼的靈活性。

使用緩衝無序流與收集的平行處理方法

在處理平行任務時，Rust 提供了一種高效的方式來管理和執行多個非同步任務。以下是一個使用 buffer_unordered 和 collect 方法來平行掃描子網域名稱的範例：

let scan_result: Vec<Subdomain> = stream::iter(subdomains.into_iter())
    .map(|subdomain| ports::scan_ports(ports_concurrency, subdomain))
    .buffer_unordered(subdomains_concurrency)
    .collect()
    .await;

內容解密：

stream::iter(subdomains.into_iter())：將 subdomains 轉換為一個迭代器，並建立一個流（stream）。
.map(|subdomain| ports::scan_ports(ports_concurrency, subdomain))：對每個子網域名稱執行 scan_ports 函式，並將結果對映到新的流中。
.buffer_unordered(subdomains_concurrency)：無序緩衝流中的任務，控制平行度為 subdomains_concurrency。
.collect().await：收集所有任務的結果，並將其聚合成一個 Vec。

埠掃描的平行處理

在掃描特定主機的所有埠時，使用流（stream）作為工作池可以有效地進行平行處理。

pub async fn scan_ports(concurrency: usize, subdomain: Subdomain) -> Subdomain {
    let mut ret = subdomain.clone();
    let socket_addresses: Vec<SocketAddr> = format!("{}:1024", subdomain.domain)
        .to_socket_addrs()
        .expect("port scanner: Creating socket address")
        .collect();
    if socket_addresses.len() == 0 {
        return subdomain;
    }
    let socket_address = socket_addresses[0];
    
    // 使用通道進行平行處理
    let (input_tx, input_rx) = mpsc::channel(concurrency);
    let (output_tx, output_rx) = mpsc::channel(concurrency);
    
    tokio::spawn(async move {
        for port in MOST_COMMON_PORTS_100 {
            let _ = input_tx.send(*port).await;
        }
    });
    
    let input_rx_stream = tokio_stream::wrappers::ReceiverStream::new(input_rx);
    input_rx_stream
        .for_each_concurrent(concurrency, |port| {
            let output_tx = output_tx.clone();
            async move {
                let port = scan_port(socket_address, port).await;
                if port.is_open {
                    let _ = output_tx.send(port).await;
                }
            }
        })
        .await;
    
    drop(output_tx);
    let output_rx_stream = tokio_stream::wrappers::ReceiverStream::new(output_rx);
    ret.open_ports = output_rx_stream.collect().await;
    ret
}

內容解密：

tokio::spawn：生成一個非同步任務來傳送埠號到通道中。
for_each_concurrent：平行處理接收到的埠號，並掃描相應的埠。
scan_port：掃描特定埠的函式，檢查埠是否開放。
output_rx_stream.collect().await：收集所有開放埠的結果。

單一埠掃描與超時處理

在掃描單一埠時，需要設定超時機制以避免長時間等待。

async fn scan_port(mut socket_address: SocketAddr, port: u16) -> Port {
    let timeout = Duration::from_secs(3);
    socket_address.set_port(port);
    let is_open = matches!(
        tokio::time::timeout(timeout, TcpStream::connect(&socket_address)).await,
        Ok(Ok(_)),
    );
    Port {
        port: port,
        is_open,
    }
}

內容解密：

tokio::time::timeout：設定連線超時為3秒。
TcpStream::connect：嘗試建立到指定埠的TCP連線。
matches! 宏：簡化模式匹配，檢查連線是否成功建立。

如何防禦

不要阻塞事件迴圈：將阻塞任務派發到專用執行緒池中執行。
避免在非同步函式中呼叫非非同步函式：確保非同步函式中的操作不會阻塞事件迴圈。

新增模組與特徵物件

泛型程式設計提高了程式碼的重用性和可靠性。在Rust中，函式、結構體和特徵都可以是泛型的。

泛型

泛型允許函式、結構體和特徵在型別上保持抽象，直到例項化時才確定具體型別。

fn add<T: Add<Output = T>>(x: T, y: T) -> T {
    return x + y;
}

內容解密：

T: Add<Output = T>：型別 T 必須實作 Add 特徵，並且其輸出型別也是 T。
泛型函式：add 函式可以對任何實作了 Add 特徵的型別進行加法運算。

泛型結構體與列舉

struct Point<T> {
    x: T,
    y: T,
}

enum Option<T> {
    Some(T),
    None,
}

內容解密：

Point<T>：一個泛型結構體，可以表示任意型別的二維點。
Option<T>：一個泛型列舉，用於表示可能存在或不存在的值。

Rust 程式語言中的泛型與特徵（Traits）詳解

Rust 語言以其嚴格的型別系統和強大的泛型（Generics）支援而聞名。泛型允許開發者編寫可重用且型別安全的程式碼。在本章中，我們將探討 Rust 中的泛型以及特徵（Traits）的使用，並瞭解它們如何協助我們編寫更具彈性和可維護性的程式碼。

4.1 泛型（Generics）

泛型是一種允許我們編寫可與多種資料型別一起工作的程式碼的機制。它們是 Rust 型別系統的重要組成部分，讓我們能夠編寫靈活且可重用的函式、結構體和列舉。

4.1.1 為何需要泛型？

在沒有泛型的情況下，如果我們需要為不同的資料型別實作相同的功能，就必須為每種型別編寫重複的程式碼。例如，如果我們想要為 i32 和 String 實作一個簡單的容器，我們就需要編寫兩個不同的版本。這不僅繁瑣，而且容易出錯。

4.1.2 泛型的基本用法

Rust 中的泛型使用尖括號 <> 來定義。例如，我們可以定義一個泛型的結構體，如下所示：

struct Container<T> {
    value: T,
}

impl<T> Container<T> {
    fn new(value: T) -> Self {
        Container { value }
    }

    fn get_value(&self) -> &T {
        &self.value
    }
}

fn main() {
    let int_container = Container::new(42);
    println!("Integer value: {}", int_container.get_value());

    let string_container = Container::new("Hello".to_string());
    println!("String value: {}", string_container.get_value());
}

#### 內容解密：

在這個例子中，Container 結構體使用了泛型 T，使得它可以儲存任何型別的資料。
impl<T> Container<T> 為 Container<T> 實作了方法，無論 T 是什麼型別。
new 方法建立了一個新的 Container 例項，而 get_value 方法傳回對儲存值的參照。

4.1.3 使用泛型的好處

使用泛型有幾個好處：

程式碼重用：泛型允許我們編寫一次程式碼，然後用於多種資料型別。
型別安全：Rust 的泛型是型別安全的，這意味著編譯器會確保在編譯時使用正確的型別。
效能：由於 Rust 的泛型是在編譯時單態化（Monomorphization），因此不會有執行時的效能損失。

4.2 特徵（Traits）

特徵是 Rust 中用於定義分享行為的機制。它們類別似於其他語言中的介面（Interfaces），但具有一些獨特的功能。

4.2.1 定義特徵

要定義一個特徵，我們使用 trait 關鍵字：

pub trait Dog {
    fn bark(&self) -> String;
}

pub struct Labrador {}

impl Dog for Labrador {
    fn bark(&self) -> String {
        "wouf".to_string()
    }
}

pub struct Husky {}

impl Dog for Husky {
    fn bark(&self) -> String {
        "Wuuuuuu".to_string()
    }
}

fn main() {
    let labrador = Labrador {};
    println!("{}", labrador.bark());

    let husky = Husky {};
    println!("{}", husky.bark());
}

#### 內容解密：

Dog 特徵定義了一個 bark 方法，任何實作 Dog 的型別都必須提供這個方法的實作。
Labrador 和 Husky 都實作了 Dog 特徵，但提供了不同的 bark 方法實作。

4.2.2 預設實作

特徵方法可以有預設實作：

pub trait Hello {
    fn hello(&self) -> String {
        String::from("World")
    }
}

pub struct Sylvain {}

impl Hello for Sylvain {
    fn hello(&self) -> String {
        String::from("Sylvain")
    }
}

pub struct Anonymous {}

impl Hello for Anonymous {}

fn main() {
    let sylvain = Sylvain {};
    let anonymous = Anonymous {};

    println!("Sylvain: {}", sylvain.hello());
    println!("Anonymous: {}", anonymous.hello());
}

#### 內容解密：

Hello 特徵有一個預設的 hello 方法實作，傳回 “World”。
Sylvain 型別覆寫了預設實作，而 Anonymous 型別使用了預設實作。

圖表說明

  graph TD;
    A[開始] --> B{是否實作特徵？};
    B -->|是| C[使用特徵方法];
    B -->|否| D[提供預設實作];
    C --> E[呼叫特徵方法];
    D --> E;

圖表翻譯： 此圖示描述了特徵的使用流程。首先檢查是否為某個型別實作了特徵，如果已經實作，則可以直接使用該特徵的方法。如果沒有實作，則可以使用特徵提供的預設實作。最終，都可以呼叫特徵方法來執行對應的操作。

4.3 特徵物件（Trait Objects）

當我們需要將不同型別的資料儲存在同一個集合中，但這些型別都實作了某個共同的特徵時，特徵物件就派上了用場。

trait UsbModule {
    // ...
}

struct UsbCamera {
    // ...
}

impl UsbModule for UsbCamera {
    // ...
}

struct UsbMicrophone {
    // ...
}

impl UsbModule for UsbMicrophone {
    // ...
}

let peripheral_devices: Vec<Box<dyn UsbModule>> = vec![
    Box::new(UsbCamera::new()),
    Box::new(UsbMicrophone::new()),
];

#### 內容解密：

使用 Box<dyn UsbModule> 建立了一個特徵物件向量，可以儲存任何實作了 UsbModule 特徵的型別。
Box::new() 用於在堆積上分配物件並傳回一個指向它的智慧指標。

隨著 Rust 生態系統的不斷發展和成熟，泛型和特徵將繼續在各種程式函式庫和框架中扮演重要角色。未來，我們可以期待看到更多根據這些概念的創新和最佳實踐，這將進一步鞏固 Rust 在系統程式設計領域的地位。同時，隨著更多開發者加入 Rust 社群並貢獻自己的經驗和見解，我們將看到更多優秀的開源專案和商業產品採用 Rust，從而推動整個產業向著更安全、更高效的方向發展。

總之，掌握 Rust 的泛型和特徵對於任何希望深入瞭解和使用 Rust 的開發者來說都是至關重要的。透過不斷學習和實踐，我們可以更好地利用這些強大的工具來構建更優秀的軟體。

玄貓

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