Rust 中的异步编程 —— 探索 Tokio 与 Async-std

Alexander Obregon 2023-05-24

引言

异步编程允许任务并发执行，从而显著提升应用程序的性能。在本文中，我们将探讨 Rust 中的异步编程，并重点介绍两个流行的库 —— Tokio 和 Async-std。

理解异步编程

在传统的同步编程中，任务按顺序依次执行。如果某个任务缓慢或处于阻塞状态，它可能会拖慢整个进程。而异步编程则允许多个任务并发运行，通常能更高效地利用系统资源。

Rust 是一门注重安全性和性能的系统级编程语言，为异步编程提供了良好的支持。

Rust 中的异步编程

Rust 的 async/await 语法为异步编程提供了一个强大且高级的基础。它使你能够编写出如同同步代码一样易于阅读和书写的异步代码。

以下是一个使用 async/await 的基本示例：

async fn hello_world() {
    println!("Hello, World!");
}

#[tokio::main]  // 如果你使用的是 async-std，则可写为 #[async_std::main]
async fn main() {
    hello_world().await;
}

在这个例子中，hello_world() 是一个异步函数。要调用它，我们使用 .await 语法。主函数 main 本身也是异步的，这使得我们可以 await 调用 hello_world() 函数。

探索 Tokio 与 Async-std

Tokio 和 Async-std 是两个为运行 Rust 异步代码提供运行时（runtime）的库。它们都提供了诸如异步 I/O 和定时器等特性，但在设计哲学和实现方式上有所不同。

Tokio

Tokio 是一个用于使用 Rust 编写可靠异步应用程序的运行时。它的目标是提供一个类似于标准库的异步版本，类似于 Node.js 为 JavaScript 提供的方式。

以下是一个简单的 Tokio TCP 回显服务器示例：

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

#[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];

            loop {
                let n = match socket.read(&mut buf).await {
                    Ok(n) if n == 0 => return,
                    Ok(n) => n,
                    Err(e) => {
                        eprintln!("failed to read from socket; err = {:?}", e);
                        return;
                    }
                };

                if let Err(e) = socket.write_all(&buf[0..n]).await {
                    eprintln!("failed to write to socket; err = {:?}", e);
                    return;
                }
            }
        });
    }
}

Async-std

Async-std 是 Rust 的另一个异步运行时。其主要卖点在于与 Rust 标准库的高度相似性。如果你熟悉 Rust 的标准库，那么使用 Async-std 会感到非常自然。

以下是一个使用 Async-std 与 Tide（一个 Web 服务器框架）构建的 HTTP 服务器示例：

use async_std::task;
use tide::prelude::*;
use tide::Request;

#[derive(Debug, Serialize, Deserialize)]
struct Message {
    author: Option<String>,
    contents: String,
}

#[async_std::main]
async fn main() -> tide::Result<()> {
    let mut app = tide::new();
    app.at("/message").post(|mut req: Request<()>| async move {
        let msg: Message = req.body_json().await?;
        println!(
            "Received a new message from {:?}: {}",
            msg.author.unwrap_or_else(|| "anonymous".to_string()),
            msg.contents
        );
        Ok("Message received")
    });

    app.listen("127.0.0.1:8080").await?;
    Ok(())
}

在这个应用中，我们设置了一个简单的 HTTP 服务器，监听 /message 端点上的 POST 请求。当收到请求时，它尝试将请求体解析为 Message 结构体，并将消息打印到控制台。该示例还展示了 Async-std 与其他异步库（在此例中为 Tide Web 框架）的良好集成。

Tokio 与 Async-std 的性能差异

尽管 Tokio 和 Async-std 都旨在实现高性能的异步操作，但它们之间的性能差异往往取决于具体的应用场景。对于许多应用程序而言，这种差异可能微乎其微。

Tokio 凭借其丰富的功能集，特别适合处理大量并发连接，因此在高并发网络应用中备受青睐。另一方面，Async-std 提供了与标准库高度一致的体验，在广泛的任务场景中通常能提供与 Tokio 相当的性能。

然而，“性能”受多种因素影响，包括具体的工作负载、硬件环境以及配置方式。对于构建关键型应用的开发者来说，建议在尽可能模拟生产环境的条件下对两个库进行基准测试。此外，值得注意的是，这两个库都在持续演进，其性能特征也可能随着新版本发布而发生变化。

底层机制：Async-std 如何实现 async/await？

与 Tokio 类似，Async-std 在内部也使用事件循环（或称 reactor）。当在 Async-std 中 await 一个异步操作时，当前任务会将控制权交还给这个事件循环，从而允许它执行其他任务。一旦被等待的操作完成，事件循环就会从上次中断的位置恢复该任务的执行。

Async-std 的设计目标是让异步编程既高效又简单。它深度集成了 Rust 的 async/await 语法，以提供标准库的异步版本。Async-std 的一个核心组件是其 reactor，它负责驱动异步 I/O 资源并调度任务。这种工作机制与 Tokio 非常相似。为了实现这一点，该库利用了操作系统提供的异步 I/O 接口（例如 Linux 上的 epoll、macOS 和 BSD 上的 kqueue，以及 Windows 上的 IOCP），以便在 I/O 资源就绪时获得通知，而不会造成阻塞。

如何在 Tokio 与 Async-std 之间选择？

在选择 Tokio 还是 Async-std 时，请考虑生态系统的成熟度以及你所需的支持类型。如果你需要更庞大的生态系统和更多的第三方库支持，Tokio 可能是更好的选择。反之，如果你更看重简洁性以及与标准库的熟悉感，那么 Async-std 可能更适合你。

请记住，Tokio 和 Async-std 都是非常优秀的库。你的选择最终应基于项目的具体需求。

结论

Rust 中的异步编程是编写高性能应用程序的强大工具。借助 async/await 语法，编写异步代码变得前所未有的简单。像 Tokio 和 Async-std 这样的库为执行这些代码提供了运行时支持，各自具备独特的优势。