Rust 高并发编程入门指南

Rust 语言以其强大的内存安全和并发模型，成为构建高效且安全的并发程序的首选。以下是 Rust 中一些常用的高并发编程技巧和工具。

1. 多线程（Threads）

• 使用场景：适合于 CPU 密集型任务或少量并发需求。
• 实现方式 ：通过 std::thread 模块创建线程，每个线程有自己的栈空间和操作系统资源。
• 注意事项：创建大量线程可能导致性能问题，因此需要谨慎使用。

示例代码：

rust
use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("Hello from a new thread!");
    });
    handle.join().unwrap();
}

2. 异步编程（Async/Await）

• 使用场景：适合于大量并发和异步 IO 操作。
• 实现方式 ：使用 async 和 await 关键字，结合 tokio 或 async-std 等异步运行时库。
• 优点：高效的非阻塞异步代码，适合处理大量并发任务。

示例代码：

rust
use tokio;

#[tokio::main]
async fn main() {
    println!("Hello from async main!");
    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
}

3. 协程（Coroutines）

• 使用场景：与异步编程类似，适合于高并发场景。
• 实现方式 ：通过异步编程模型实现，使用 async_std::task 或 tokio::task 等库。

示例代码：

rust
use tokio::task;

#[tokio::main]
async fn main() {
    let handle = task::spawn(async {
        println!("Hello from a coroutine!");
    });
    handle.await.unwrap();
}

4. 通道（Channels）

• 使用场景：用于线程间通信，避免共享状态。
• 实现方式 ：使用 std::sync::mpsc 模块创建通道，实现发送端和接收端之间的数据传递。

示例代码：

rust
use std::sync::mpsc;

fn main() {
    let (tx, rx) = mpsc::channel();
    let handle = std::thread::spawn(move || {
        tx.send("Hello from another thread!").unwrap();
    });
    println!("Received: {}", rx.recv().unwrap());
    handle.join().unwrap();
}

5. 工作者线程池（Worker Thread Pool）

• 使用场景：适合于管理多个工作线程，提高资源利用率。
• 实现方式 ：使用第三方库如 rayon 实现线程池，分配任务给池中的线程执行。

示例代码：

rust
use rayon::prelude::*;

fn main() {
    let data = vec![1, 2, 3, 4, 5];
    let result: Vec<_> = data.into_par_iter().map(|x| x * 2).collect();
    println!("{:?}", result); // 输出: [2, 4, 6, 8, 10]
}

6. 无锁数据结构（Lock-Free Data Structures）

• 使用场景：在并发环境中提高性能，避免锁竞争。
• 实现方式：利用原子操作和内存模型，使用标准库中的原子类型或第三方库。

示例代码：

rust
use std::sync::atomic::{AtomicUsize, Ordering};

fn main() {
    let counter = AtomicUsize::new(0);
    let handle = std::thread::spawn(move || {
        counter.fetch_add(1, Ordering::SeqCst);
    });
    handle.join().unwrap();
    println!("Counter: {}", counter.load(Ordering::SeqCst));
}

7. 响应式编程（Reactive Programming）

• 使用场景：处理异步数据流和事件流，适合实时响应场景。
• 实现方式 ：使用异步编程和流处理库，如 futures-rs 和 async-stream。

示例代码：

rust
use futures::stream::StreamExt;

async fn main() {
    let stream = futures::stream::iter(1..=5);
    while let Some(item) = stream.next().await {
        println!("Received: {}", item);
    }
}

8. Sync 和 Send Traits

• 使用场景：确保数据在多线程间的安全访问。
• 实现方式 ：使用 Sync 和 Send traits 来选择合适的类型，如 Arc 代替 Rc。

示例代码：

rust
use std::sync::Arc;

fn main() {
    let shared_data = Arc::new(10);
    let handle = std::thread::spawn({
        let shared_data = Arc::clone(&shared_data);
        move || {
            println!("Shared data: {}", *shared_data);
        }
    });
    handle.join().unwrap();
}

9. 读写锁（RWMutex）

• 使用场景：适用于读多写少的场景，提高并发性能。
• 实现方式 ：使用 std::sync::RwLock 或 tokio::sync::RwLock 等库。

示例代码：

rust
use std::sync::{Arc, RwLock};

fn main() {
    let shared_state = Arc::new(RwLock::new(0));
    let handle = std::thread::spawn({
        let shared_state = Arc::clone(&shared_state);
        move || {
            let mut state = shared_state.write().unwrap();
            *state += 1;
        }
    });
    handle.join().unwrap();
    println!("Final state: {}", *shared_state.read().unwrap());
}