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 与 运行时 的职责分离。

0 赞

0 踩