King - 个人技术博客

引言

Rust的并发模型提供了强大的工具来编写安全、高效的并发程序，同时通过类型系统和所有权规则防止数据竞争。

在现代编程中，充分利用多核处理器的能力变得越来越重要。Rust通过其独特的所有权系统和类型检查，在编译时就能够防止许多常见的并发错误，使得编写并发程序变得更加安全和可靠。

使用线程

use std::thread;
use std::time::Duration;
 
fn main() {
    // 创建一个新线程
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("在新线程中：数字 {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });
 
    // 主线程中的工作
    for i in 1..5 {
        println!("在主线程中：数字 {}", i);
        thread::sleep(Duration::from_millis(1));
    }
 
    // 等待新线程完成
    handle.join().unwrap();
}

使用move闭包

use std::thread;
 
fn main() {
    let v = vec![1, 2, 3];
 
    let handle = thread::spawn(move || {
        println!("这是向量：{:?}", v);
    });
 
    handle.join().unwrap();
}

消息传递

use std::sync::mpsc;
use std::thread;
 
fn main() {
    // 创建一个通道
    let (tx, rx) = mpsc::channel();
 
    // 创建多个发送者
    let tx1 = tx.clone();
 
    // 在一个新线程中发送消息
    thread::spawn(move || {
        let vals = vec![
            String::from("你好"),
            String::from("从"),
            String::from("线程"),
            String::from("发送"),
        ];
 
        for val in vals {
            tx1.send(val).unwrap();
            thread::sleep(Duration::from_secs(1));
        }
    });
 
    // 在另一个线程中发送更多消息
    thread::spawn(move || {
        let vals = vec![
            String::from("更多"),
            String::from("消息"),
            String::from("发送"),
        ];
 
        for val in vals {
            tx.send(val).unwrap();
            thread::sleep(Duration::from_secs(1));
        }
    });
 
    // 在主线程中接收消息
    for received in rx {
        println!("收到：{}", received);
    }
}

共享状态并发

use std::sync::{Arc, Mutex};
use std::thread;
 
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!("结果：{}", *counter.lock().unwrap());
}

使用通道进行复杂通信

use std::sync::mpsc;
use std::thread;
use std::time::Duration;
 
enum WorkerMessage {
    NewJob(String),
    Terminate,
}
 
struct Worker {
    id: usize,
    receiver: mpsc::Receiver<WorkerMessage>,
}
 
impl Worker {
    fn new(id: usize, receiver: mpsc::Receiver<WorkerMessage>) -> Worker {
        Worker { id, receiver }
    }
 
    fn run(&self) {
        loop {
            match self.receiver.recv().unwrap() {
                WorkerMessage::NewJob(job) => {
                    println!("工作者 {} 开始处理任务：{}", self.id, job);
                    thread::sleep(Duration::from_secs(1));
                }
                WorkerMessage::Terminate => {
                    println!("工作者 {} 收到终止信号", self.id);
                    break;
                }
            }
        }
    }
}
 
fn main() {
    let (tx, rx) = mpsc::channel();
    let worker = Worker::new(1, rx);
 
    let worker_thread = thread::spawn(move || {
        worker.run();
    });
 
    // 发送一些任务
    for i in 1..5 {
        tx.send(WorkerMessage::NewJob(format!("任务 {}", i))).unwrap();
    }
 
    // 发送终止信号
    tx.send(WorkerMessage::Terminate).unwrap();
 
    // 等待工作者线程完成
    worker_thread.join().unwrap();
}

并发编程最佳实践

使用消息传递作为首选的并发通信方式
当需要共享状态时，使用适当的同步原语（Mutex、RwLock等）
避免过度使用锁，可能导致性能问题和死锁
使用Arc（原子引用计数）在线程间共享数据
正确处理错误和panic情况
使用适当的错误处理机制（Result、unwrap等）

性能考虑

避免创建过多线程，考虑使用线程池
合理划分任务，保持适当的粒度
注意锁的持有时间，尽量减少临界区
使用无锁数据结构提高并发性能
考虑使用异步编程替代线程

总结

Rust的并发编程模型通过类型系统和所有权规则提供了强大的安全保证，同时保持了高性能。通过合理使用线程、消息传递和共享状态，我们可以编写出安全、高效的并发程序。虽然学习曲线可能较陡，但这些概念的掌握对于编写现代化的并发程序至关重要。