Rust在Linux中的并发处理

Rust在Linux中的并发处理非常强大且灵活，主要依赖于其标准库中提供的各种并发原语。以下是一些关键概念和示例代码，帮助你理解如何在Rust中处理并发。

基本并发原语

1. 线程（Threads）： Rust通过std::thread模块提供了创建和管理线程的功能。

   use std::thread;
   
   fn main() {
       let handle = thread::spawn(|| {
           println!("这是新线程!");
       });
   
       handle.join().unwrap();
   }
   

2. 共享内存与互斥锁（Mutex）： 使用Mutex确保多个线程安全地访问共享数据。

   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());
   }
   

3. 线程间通信（Channels）： 使用mpsc模块创建多生产者单消费者（MPSC）通道进行线程间通信。

   use std::sync::mpsc;
   use std::thread;
   
   fn main() {
       let (tx, rx) = mpsc::channel();
   
       thread::spawn(move || {
           tx.send("hello").unwrap();
       });
   
       let message = rx.recv().unwrap();
       println!("Received: {}", message);
   }
   

高级并发原语

1. 原子操作（Atomic Operations）： 使用std::sync::atomic模块进行低级别的原子操作。

   use std::sync::atomic::{AtomicUsize, Ordering};
   use std::sync::Arc;
   use std::thread;
   
   fn main() {
       let counter = Arc::new(AtomicUsize::new(0));
       let mut handles = vec![];
   
       for _ in 0..10 {
           let counter = Arc::clone(&counter);
           let handle = thread::spawn(move || {
               counter.fetch_add(1, Ordering::SeqCst);
           });
           handles.push(handle);
       }
   
       for handle in handles {
           handle.join().unwrap();
       }
   
       println!("计数器值: {}", counter.load(Ordering::SeqCst));
   }
   

2. 读写锁（RwLock）： 使用std::sync::RwLock允许多个读取者同时访问数据，但只允许一个写入者。

   use std::sync::{Arc, RwLock};
   use std::thread;
   
   fn main() {
       let data = Arc::new(RwLock::new(0));
       let mut handles = vec![];
   
       for i in 0..10 {
           let data = Arc::clone(&data);
           let handle = thread::spawn(move || {
               let mut num = data.write().unwrap();
               *num += 1;
           });
           handles.push(handle);
       }
   
       for handle in handles {
           handle.join().unwrap();
       }
   
       println!("数据值: {}", *data.read().unwrap());
   }
   

其他资源

• Rust并发编程手册

通过这些基础知识和工具，你可以在Rust中构建高效且安全的并发程序。