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

struct Counter {
    count: Mutex<i32>,
}

impl Counter {
    fn new() -> Self {
        Counter {
            count: Mutex::new(0),
        }
    }
    
    fn increment(&self) {
        let mut count = self.count.lock().unwrap();
        *count += 1;
    }
    
    fn get_count(&self) -> i32 {
        *self.count.lock().unwrap()
    }
}

fn main() {
    let counter = Arc::new(Counter::new());
    let mut handles = vec![];
    
    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            for _ in 0..100 {
                counter.increment();
            }
        });
        handles.push(handle);
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    println!("最終計數: {}", counter.get_count()); // 應該是 1000
}

練習 2: 異步任務處理

建立一個異步函數，並發處理多個任務並收集結果：

查看答案

use tokio;
use std::time::Duration;

async fn process_task(id: i32) -> String {
    tokio::time::sleep(Duration::from_millis(100)).await;
    format!("任務 {} 完成", id)
}

async fn process_all_tasks() -> Vec<String> {
    let mut handles = vec![];
    
    for i in 0..10 {
        let handle = tokio::spawn(async move {
            process_task(i).await
        });
        handles.push(handle);
    }
    
    let mut results = vec![];
    for handle in handles {
        let result = handle.await.unwrap();
        results.push(result);
    }
    
    results
}

#[tokio::main]
async fn main() {
    let results = process_all_tasks().await;
    println!("所有任務完成: {:?}", results);
}

練習 3: 生產者消費者模式

實現一個生產者消費者模式，使用通道進行執行緒間通訊：

查看答案

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn producer_consumer() {
    let (tx, rx) = mpsc::channel();
    
    // 生產者
    let producer = thread::spawn(move || {
        for i in 0..10 {
            tx.send(format!("產品 {}", i)).unwrap();
            thread::sleep(Duration::from_millis(100));
        }
    });
    
    // 消費者
    let consumer = thread::spawn(move || {
        for received in rx {
            println!("消費: {}", received);
        }
    });
    
    producer.join().unwrap();
    consumer.join().unwrap();
}

fn main() {
    producer_consumer();
}

📝 總結

在這一章中，我們學習了 Rust 的並發和異步程式設計：

執行模型: Rust 支援真正的多執行緒並行，JavaScript 是單執行緒事件循環
執行緒安全: Rust 透過所有權系統在編譯時保證執行緒安全
異步程式設計: Rust 的 async/await 語法與 JavaScript 類似
並發模式: 使用 Arc、Mutex、RwLock 等型別安全地共享狀態
效能選擇: 多執行緒適合 CPU 密集型，異步適合 I/O 密集型

關鍵要點

Rust 的所有權系統確保執行緒安全
異步程式設計提供高性能的 I/O 處理
選擇合適的並發模型很重要
編譯時檢查避免執行時錯誤

下一步學習

在下一章中，我們將學習 Rust 的型別系統和特徵（Traits），了解如何建構可複用的抽象。

繼續學習: 型別系統與特徵

並發與異步模型

On this page