要在CentOS上玩转Rust的并发编程，第一步自然是把Rust装好。官方推荐使用rustup这个工具链安装器，一条命令就能搞定：

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

安装完成后，记得重载shell环境，让Rust命令生效：

source $HOME/.cargo/env

用rustc --version和cargo --version验证一下，确认一切正常。

创建项目环境

接下来，用Cargo创建一个新项目，就叫concurrency_demo吧：

cargo new concurrency_demo
cd concurrency_demo

这个命令会生成一个标准项目结构，包含src/main.rs和Cargo.toml清单文件。

之后所有的并发实验都在这里进行。

并发编程的几种常见方式

1. 线程并发 (Thread-Based Concurrency)

Rust标准库提供了std::thread模块，用来创建和管理线程。

其中thread::spawn函数可以创建新线程并执行传入的闭包，join()则用于等待线程结束。来看一个基础例子：

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("Hello from a spawned thread!");
    });
    println!("Hello from the main thread!");
    handle.join().unwrap(); // 阻塞直到线程完成
}

这段代码展示了线程创建和同步的基本用法。

主线程和子线程交替输出，最后通过join()确保子线程执行完毕。

2. 消息传递 (Message Passing with Channels)

Rust鼓励用消息传递来避免数据竞争，而不是依赖共享状态。

std::sync::mpsc模块（多生产者、单消费者）提供了通道，用于线程间的安全通信：

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel(); // 创建通道，tx为发送端，rx为接收端
    thread::spawn(move || {
        let val = String::from("Message from thread");
        tx.send(val).unwrap(); // 向主线程发送数据
    });
    let received = rx.recv().unwrap(); // 接收数据（阻塞直到消息到达）
    println!("Received: {}", received);
}

通道保证了线程间通信的安全性，无需显式加锁，代码也更加清晰。

3. 共享状态 (Shared State with Arc and Mutex)

如果确实需要共享状态，可以用Arc（原子引用计数）实现线程安全的引用共享。

再配合Mutex（互斥锁）保护数据不被并发修改：

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0)); // 将计数器包裹在Arc和Mutex中
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter); // 为每个线程克隆Arc
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap(); // 获取互斥锁
            *num += 1; // 修改共享数据
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap(); // 等待所有线程完成
    }

    println!("Final counter value: {}", *counter.lock().unwrap());
}

Arc确保计数器能被多个线程安全共享，Mutex则防止同时修改。

这是Rust中处理共享状态的经典套路。

4. 异步编程 (Asynchronous Programming with Tokio)

对于高I/O密集型的任务（比如网络服务器），Rust的async/await配合tokio运行时能发挥巨大威力。

首先在Cargo.toml中添加依赖：

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

下面是一个简单的TCP回显服务器，为每个客户端连接生成一个异步任务：

use tokio::net::TcpListener;
use tokio::prelude::*;

#[tokio::main] // 宏，设置Tokio运行时
async fn main() -> Result<(), Box> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?; // 绑定到本地8080端口
    println!("Server listening on port 8080");

    loop {
        let (mut socket, addr) = listener.accept().await?; // 接受新连接
        println!("New connection from {:?}", addr);

        // 为每个客户端生成一个异步任务
        tokio::spawn(async move {
            let mut buf = [0; 1024]; // 读取缓冲区
            loop {
                match socket.read(&mut buf).await {
                    Ok(n) if n == 0 => return, // 连接关闭
                    Ok(n) => {
                        if socket.write_all(&buf[0..n]).await.is_err() {
                            eprintln!("Failed to write to socket");
                            return;
                        }
                    }
                    Err(e) => {
                        eprintln!("Failed to read from socket: {:}", e);
                        return;
                    }
                }
            }
        });
    }
}

这个例子用tokio::spawn并发处理每个客户端连接，效率很高。

它可以轻松应对大量并发连接。

关键要点总结

• 所有权与借用：Rust的所有权模型在编译期就能防止数据竞争。比如，某个数据被可变借用时，就不能再被其他引用访问。
• 线程安全：共享所有权用Arc，同步访问用Mutex或RwLock。除非万不得已，别碰裸指针和unsafe块。
• 异步最佳实践：用tokio::spawn并行处理I/O任务，但不要在异步任务中做阻塞操作（比如thread::sleep），应该改用tokio::time::sleep。

掌握这些工具，并遵循Rust的安全保证，你就能在CentOS上构建高效、可靠的并发应用程序了。