CentOS下Rust并发编程如何入门

CentOS下Rust并发编程入门指南

一 环境准备

• 在 CentOS 上安装 Rust 工具链（rustup），并配置环境变量：
  • 安装：curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
  • 生效：source $HOME/.cargo/env
• 验证：cargo --version、rustc --version
• 创建项目：cargo new concurrent_demo & & cd concurrent_demo
• 运行与构建：cargo run、cargo build

二 并发模型与最小示例

• 线程 std::thread
  • 适合并行计算、阻塞型任务；用 join 等待线程结束，避免提前退出。
  • 示例要点：
    • thread::spawn(|| { ... } ) 创建线程
    • handle.join().unwrap() 等待回收
• 消息传递 std::sync::mpsc
  • 典型 MPSC 通道，线程间通过发送/接收消息解耦，避免共享可变状态。
  • 示例要点：
    • let (tx, rx) = mpsc::channel();
    • tx.send(val).unwrap(); 发送；rx.recv().unwrap(); 接收
• 共享状态 Arc + Mutex/RwLock
  • 多个线程共享数据时，用 Arc（原子引用计数）包装，配合 Mutex/RwLock 保护临界区。
  • 示例要点：
    • let counter = Arc::new(Mutex::new(0));
    • let c = Arc::clone(& counter); 在子线程中克隆
    • let mut n = c.lock().unwrap(); *n += 1;
• 异步并发 async/await + Tokio
  • 适合 高并发 I/O 密集型 场景（网络、文件等）；基于 Future 与运行时 Runtime。
  • 示例要点：
    • 依赖：tokio = { version = "1", features = ["full"] }
    • 入口：#[tokio::main] async fn main()
    • 并发：tokio::spawn(async { ... } )；常用 select!、定时器、信号处理等组合任务。

三 示例汇总

• 线程与通道
  • 线程

    use std::thread;
    
    fn main() {
    
        let h = thread::spawn(|| {
    
            for i in 1..5 {
     println!("子线程: {
    }
        ", i);
     }
    
        }
        );
    
        for i in 1..3 {
     println!("主线程: {
    }
        ", i);
     }
        
        h.join().unwrap();
    
    }
        
    

  • 通道

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

• 共享状态

  use std::sync::{
  Arc, Mutex}
      ;
      
  use std::thread;
  
  fn main() {
      
      let c = Arc::new(Mutex::new(0));
      
      let mut hs = vec![];
  
      for _ in 0..10 {
      
          let c = Arc::clone(&
      c);
  
          hs.push(thread::spawn(move || {
      
              *c.lock().unwrap() += 1;
  
          }
      ));
  
      }
  
      for h in hs {
       h.join().unwrap();
   }
  
      println!("结果: {
  }
      ", *c.lock().unwrap());
  
  }
  
  

• 异步并发
  • Cargo.toml

    [dependencies]
    tokio = {
     version = "1", features = ["full"] }
        
    

  • main.rs

    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];
        
                while let Ok(n) = socket.read(&
    mut buf).await {
    
                    if n == 0 {
         break;
     }
        
                    if socket.write_all(&
    buf[..n]).await.is_err() {
         break;
     }
    
                }
    
            }
        );
    
        }
    
    }
        
    

以上示例覆盖了 线程、通道、共享状态、异步并发 的常用入门写法，可直接在 CentOS 上 cargo run 运行。

四 实践建议与常见坑

• 选择模型
  • CPU 密集：优先考虑多 std::thread + 工作窃取（如后续学习 rayon）
  • I/O 密集：优先 async/await + Tokio（网络、文件、数据库等）
• 共享数据最小化
  • 优先 消息传递 解耦；必须共享时用 Arc< Mutex> ，缩小临界区，避免锁粒度过大
• 错误处理与可观测性
  • 通道接收可用 recv_timeout 避免永久阻塞；线程/任务要 join 或 await 回收
  • 为线程/任务加日志与指标，便于定位阻塞与背压
• 资源与端口
  • 运行网络示例前确保 8080 端口未被占用：ss -tlnp | grep 8080
• 逐步进阶
  • 先掌握 thread/mpsc/Arc 再过渡到 Tokio；理解 Future 与 运行时 的职责分离。

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！