Rust在Ubuntu上的并发编程如何实现

在Ubuntu上，用Rust写并发是种什么体验？

很多刚接触Rust的开发者都会问，作为一个系统级语言，它到底怎么处理并发？抛开各种花哨的外部框架不说，Rust语言本身提供的那套并发机制，才是真正的底气来源。下面这篇内容，我们从头捋一遍，在Ubuntu上怎么把Rust的并发能力真正用起来。

第一步：把Rust装进你的Ubuntu

如果还没安装，一条命令就搞定：

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

装完之后，记得把~/.cargo/bin加到你的PATH里。这一步很多人会忘，导致后面cargo命令找不到，挺坑的。

第二步：用cargo新建一个项目

cargo new concurrency_example
cd concurrency_example

这样项目骨架就有了，接下来所有的并发代码都写在这个里面。

第三步：三种并发方式，你会爱上哪一种？

Rust的并发模型不只是“开个线程”那么简单。它其实提供了三个层次的工具，你可以根据场景灵活选择。

方式一：标准线程

最直接的方式，使用std::thread模块。下面这段代码，创建了一个新线程并打印一句话，主线程则调用join等待它结束：

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("Hello from a thread!");
    });
    // 等待线程结束
    handle.join().unwrap();
}

这本身没什么，但结合Rust的所有权机制，线程间的数据传递才是展示语言功底的地方。

方式二：消息传递（通道）

如果你熟悉GO语言的channel，那么Rust的std::sync::mpsc模块会让你感到亲切。它实现了多生产者、单消费者的模型。下面这个例子，一个线程发送字符串，主线程接收：

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

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let val = String::from("hi");
        tx.send(val).unwrap();
    });

    let received = rx.recv().unwrap();
    println!("Got: {}", received);
}

这里的move关键字是关键——它把值的所有权转移到闭包里，然后通过通道发送出去，整个过程没有数据竞争。你可以把它看作一个安全的“你写我读”管道。

方式三：异步编程（tokio）

如果你的场景是I/O密集型的，比如网络服务、文件读写，那么异步编程才是真正的高效方案。Rust的async/.await语法搭配tokio运行时，可以说是绝配。

首先在Cargo.toml里加上tokio的依赖：

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

然后就可以写一个最简单的TCP回显服务器：

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

#[tokio::main]
async fn main() -> Result<(), Box> {
    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];
            match socket.read(&mut buf).await {
                Ok(_) => {
                    if socket.write_all(b"Hello, world!").await.is_err() {
                        eprintln!("Failed to write to socket");
                    }
                }
                Err(e) => {
                    eprintln!("Failed to read from socket: {:?}", e);
                }
            }
        });
    }
}

这不仅仅是增加几个库那么简单。异步模型让你以近乎同步的写法，实现高效的I/O并发。每个连接都在一个轻量级的任务中处理，线程资源利用率很高。

第四步：运行与测试

写完代码之后，直接cargo run就行了。Rust的编译期检查会帮你发现绝大多数并发问题，比如数据竞争、借用冲突。在开发阶段就能把这些坑填平，比起运行时崩了再调试，要舒心得多。

第五步：持续学习

并发编程的深度远超几段代码。Rust在语言层面、标准库层面以及第三方生态系统（如tokio、async-std）都提供了丰富的支持。建议抽时间翻翻Rust官方文档的并发章节，再结合一些经典书籍（比如《Rust编程之道》）或者社区博客，慢慢就能真正理解什么是“无畏的并发”。

用Rust在Ubuntu上搞并发，其实核心不在于你学会了几个API，而在于你理解了所有权的流动和生命周期的控制。这才是真正的并发能力所在。