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