Rust在Debian上的并發編程實踐

在Debian上使用Rust進行并發編程可以充分利用Rust語言的安全性和性能優勢。Rust的所有權和類型系統為并發編程提供了強大的工具，幫助開發者避免常見的內存安全和并發問題，如競爭條件和死鎖。以下是一些在Debian上使用Rust進行并發編程的實踐方法：

創建線程

Rust的標準庫提供了1:1線程模型，使用std::thread::spawn函數可以創建新線程。例如：

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

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("this is thread {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for k in 1..5 {
        println!("this is main {}", k);
        thread::sleep(Duration::from_millis(1));
    }

    handle.join().unwrap(); // 阻塞主線程直到新線程結束
}

使用move閉包

在并發編程中，可以使用move閉包將變量的所有權從主線程轉移到閉包中。例如：

use std::thread;

fn main() {
    let v = vec![2, 4, 5];
    let handle = thread::spawn(move || {
        println!("Vector: {:?}", v);
    });

    handle.join().unwrap();
}

消息傳遞并發

Rust支持通過通道（channels）在線程之間發送消息，實現并發編程。例如：

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        tx.send(42).unwrap();
    });

    let received = rx.recv().unwrap();
    println!("Received: {}", received);
}

共享狀態并發

Rust的Sync和Send特性可以確保用戶定義的類型和標準庫提供的類型在多線程環境中安全地共享狀態。例如：

use std::thread;
use std::sync::{Arc, Mutex};

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

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

    println!("Result: {}", *counter.lock().unwrap());
}

并發與并行的區別

• 并發（Concurrent）：多個任務輪流執行，例如使用同一個咖啡機。
• 并行（Parallel）：多個任務同時執行，例如每個隊列都有自己的咖啡機。

選擇合適的并發模型

• CPU密集型：使用多線程并行處理。
• I/O密集型：使用并發模型。

Rust提供了多種工具來建模和解決并發問題，開發者可以根據具體的應用場景選擇合適的并發模型。通過利用Rust的所有權和類型系統，可以在編譯時捕獲大多數并發錯誤，從而編寫出更安全和高效的并發代碼。