Rust在Linux上的并发编程实践

Rust在Linux上的并发编程可结合语言特性、标准库及第三方库实现，以下是关键实践：

一、基础并发模型

• 线程创建与管理
  使用std::thread模块创建线程，通过Arc（原子引用计数）共享数据，Mutex或RwLock保护共享状态。

  use std::sync::{Arc, Mutex};
  use std::thread;
  let counter = Arc::new(Mutex::new(0));
  let handles: Vec<_> = (0..10).map(|_| {
      let counter = Arc::clone(&counter);
      thread::spawn(move || {
          let mut num = counter.lock().unwrap();
          *num += 1;
      })
  }).collect();
  handles.into_iter().for_each(|h| h.join().unwrap());
  println!("Result: {}", *counter.lock().unwrap());
  

• 消息传递（避免共享状态）
  通过std::sync::mpsc或crossbeam库实现多生产者-单消费者（MPSC）通道。

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

二、异步编程

• async/await语法
  基于Future trait，配合tokio或async-std运行时实现非阻塞I/O。

  use tokio::net::TcpListener;
  #[tokio::main]
  async fn main() -> Result<(), Box<dyn std::error::Error>> {
      let listener = TcpListener::bind("127.0.0.1:8080").await?;
      loop {
          let (mut socket, _) = listener.accept().await?;
          tokio::spawn(async move {
              let mut buf = [0; 1024];
              if let Ok(n) = socket.read(&mut buf).await {
                  socket.write_all(&buf[..n]).await.unwrap();
              }
          });
      }
  }
  

三、并发数据结构与优化

• 并行计算
  使用rayon库将顺序代码转换为并行处理，适用于数据并行场景。

  use rayon::prelude::*;
  let numbers = vec![1, 2, 3, 4, 5];
  let sum: i32 = numbers.par_iter().sum();
  

• 性能优化技巧

  • 避免锁竞争：使用细粒度锁或无锁数据结构（如crossbeam::queue）。
  • 异步I/O：优先使用tokio的异步文件/网络操作，减少线程阻塞。
  • 批处理与任务窃取：利用线程池的任务调度机制平衡负载。

四、常用库与工具

• 标准库：std::thread、std::sync（含Mutex/RwLock）、std::time（超时控制）。
• 第三方库：
  • tokio/async-std：异步运行时，支持高并发网络和I/O。
  • rayon：数据并行处理，简化并行代码编写。
  • crossbeam：高级并发原语（如无锁队列、MPSC通道）。

五、注意事项

• 避免死锁：确保锁的获取与释放顺序一致，优先使用try_lock避免阻塞。
• 内存安全：利用Rust所有权系统避免数据竞争，异步代码中注意Pin和Future的生命周期。

通过以上方法，可在Linux上利用Rust构建高效、安全的并发程序，兼顾性能与可靠性。