超级会员免费看
深入探索 Rust 异步编程
1. 异步 Rust 基础
异步编程允许我们在单个操作系统线程上同时处理多个任务。其实现的关键在于利用代码执行中 CPU 等待外部事件完成的情况，例如等待读写文件、网络数据到达或定时器完成。当代码在等待磁盘子系统或网络套接字的数据时，异步运行时（如 Tokio）可以调度其他异步任务继续执行。当磁盘或 I/O 子系统发出系统中断时，异步运行时会识别并调度原任务继续处理。
一般来说，I/O 密集型程序（程序进度主要取决于 I/O 子系统速度）适合异步任务执行，而 CPU 密集型程序（程序进度取决于 CPU 速度，如复杂的数值计算）则不太适合。不过这只是一个大致的指导原则，存在例外情况。
在 Web 开发中，由于涉及大量的网络、文件和数据库 I/O，正确使用异步编程可以加快程序整体执行速度，提高终端用户的响应时间。例如，Web 服务器需要处理 10000 个或更多并发连接时，为每个连接创建一个单独的操作系统线程会消耗大量系统资源。因此，许多 Rust 框架（如 Actix Web）都内置了异步运行时，Actix Web 底层使用 Tokio 库进行异步任务执行。
Rust 标准库中用于异步编程的核心内置原语是
async
和
.await
关键字，它们是 Rust 语法的特殊部分，使开发者更容易编写看起来像同步代码的异步代码。
2. 异步编程中的 Futures
Rust 异步编程的核心概念是 Futures。Futures 是异步计算（或函数）产生的最终单一值，本质上代表延迟计算。Rust 中的异步函数返回一个 Future。
以下是一个使用 Futures 重写的示例代码：
use std::thread::sleep;
use std::time::Duration;
use std::future::Future;
#[tokio::main]
async fn main() {
println!("Hello before reading file!");
let h1 = tokio::spawn(async {
let file1_contents = read_from_file1().await;
println!("{:?}", file1_contents);
});
let h2 = tokio::spawn(async {
let file2_contents = read_from_file2().await;
println!("{:?}", file2_contents);
});
let _ = tokio::join!(h1, h2);
}
// function that simulates reading from a file
fn read_from_file1() -> impl Future<Output=String> {
async {
sleep(Duration::new(4, 0));
println!("{:?}", "Processing file 1");
String::from("Hello, there from file 1")
}
}
// function that simulates reading from a file
fn read_from_file2() -> impl Future<Output=String> {
async {
sleep(Duration::new(3, 0));
println!("{:?}", "Processing file 2");
String::from("Hello, there from file 2")
}
}
运行该程序，输出结果如下：
Hello before reading file!
"Processing file 2"
"Hello, there from file 2"
"Processing file 1"
"Hello, there from file 1"
在这个示例中，
read_from_file1()
和
read_from_file2()
函数的返回值从
String
变为
impl Future<Output=String>
，表示函数返回一个实现了
Future
特征的对象。
async
关键字定义了一个异步块或函数，编译器会将其转换为生成 Future 的代码。
Future
特征的定义如下：
pub trait Future {
type Output;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}
Output
类型表示 Future 成功完成时返回的数据类型。
poll
方法由异步运行时调用，用于检查异步计算是否完成，它返回一个枚举类型的值：
-
Poll::Pending
：表示 Future 尚未准备好。
-
Poll::Ready(val)
：表示 Future 已成功完成并返回值
val
。
Rust 的 Futures 是惰性的，需要异步执行器不断跟进以完成计算。Tokio 库中的 Future 执行器会调用
poll
方法来驱动 Futures 完成。
3. 理解 Futures 的工作原理
为了更好地理解 Futures，我们以 Tokio 异步库为例。Tokio 运行时管理异步任务并将其调度到处理器上执行。一个程序中可以生成多个异步任务，每个异步任务可能包含一个或多个 Futures。
以下是一个自定义 Future 的示例代码：
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use std::thread::sleep;
use std::time::Duration;
struct ReadFileFuture {}
impl Future for ReadFileFuture {
type Output = String;
fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
println!("Tokio! Stop polling me");
Poll::Pending
}
}
#[tokio::main]
async fn main() {
println!("Hello before reading file!");
let h1 = tokio::spawn(async {
let future1 = ReadFileFuture {};
future1.await
});
let h2 = tokio::spawn(async {
let file2_contents = read_from_file2().await;
println!("{:?}", file2_contents);
});
let _ = tokio::join!(h1, h2);
}
// function that simulates reading from a file
fn read_from_file2() -> impl Future<Output = String> {
async {
sleep(Duration::new(2, 0));
println!("{:?}", "Processing file 2");
String::from("Hello, there from file 2")
}
}
运行该程序，输出结果如下：
Hello before reading file!
Tokio! Stop polling me
"Processing file 2"
"Hello, there from file 2"
程序不会终止，会一直挂起，因为
ReadFileFuture
的
poll
方法始终返回
Poll::Pending
。
Tokio 执行器通过
Waker
组件来知道何时再次轮询 Future。当异步执行器轮询的任务未准备好产生值时，任务会注册到
Waker
上，
Waker
的
wake()
方法可以通知异步执行器再次轮询该任务。
修改
ReadFileFuture
的
poll
方法如下：
impl Future for ReadFileFuture {
type Output = String;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
println!("Tokio! Stop polling me");
cx.waker().wake_by_ref();
Poll::Pending
}
}
运行修改后的程序，
poll
方法会不断被调用，因为
wake_by_ref()
方法会通知异步执行器再次轮询该任务。
4. Tokio 组件的工作流程
Tokio 运行时需要理解操作系统（内核）方法（如
epoll
）来启动 I/O 操作。Tokio 运行时会注册异步处理程序，当 I/O 操作发生事件时调用。Tokio 运行时中监听内核事件并与其他组件通信的部分是反应器（reactor）。Tokio 执行器负责将 Future 驱动到完成，当 Future 可以继续执行时调用其
poll
方法。
Futures 通过调用
Waker
组件的
wake()
方法来通知执行器它们已准备好继续执行。
Waker
组件会通知执行器将 Future 放回队列并再次调用
poll
方法，直到 Future 完成。
以下是 Tokio 各组件协同工作读取文件的简化流程：
1. 程序的
main
函数在 Tokio 运行时上生成异步任务 1。
2. 异步任务 1 包含一个从大文件读取数据的 Future。
3. 读取文件的请求被交给内核的文件子系统。
4. 同时，Tokio 运行时调度异步任务 2 进行处理。
5. 当异步任务 1 的文件操作完成时，文件子系统触发操作系统中断，该中断被转换为 Tokio 反应器识别的事件。
6. Tokio 反应器通知异步任务 1 文件操作的数据已准备好。
7. 异步任务 1 通知与其注册的
Waker
组件它已准备好产生值。
8.
Waker
组件通知 Tokio 执行器调用与异步任务 1 关联的
poll
方法。
9. Tokio 执行器调度异步任务 1 进行处理并调用
poll
方法。
10. 异步任务 1 产生值。
5. 自定义 Future 返回有效值
修改
ReadFileFuture
的
poll
方法，使其返回有效值：
impl Future for ReadFileFuture {
type Output = String;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
println!("Tokio! Stop polling me");
cx.waker().wake_by_ref();
Poll::Ready(String::from("Hello, there from file 1"))
}
}
运行修改后的程序，输出结果如下：
Hello before reading file!
Tokio! Stop polling me
"Hello, there from file 1"
"Hello, there from file 2"
总结
通过本文，我们深入了解了 Rust 异步编程的基础知识，包括异步编程的原理、
Future
特征的使用、Tokio 运行时的工作流程以及自定义 Future 的实现。掌握这些知识可以帮助我们更好地编写高效的异步 Rust 程序。
流程图
graph TD;
A[main函数] --> B[生成异步任务1];
A --> C[生成异步任务2];
B --> D[异步任务1包含读取文件的Future];
D --> E[请求交给内核文件子系统];
C --> F[异步任务2被调度处理];
E --> G[文件操作完成触发中断];
G --> H[Tokio反应器识别事件];
H --> I[通知异步任务1数据准备好];
I --> J[异步任务1通知Waker组件];
J --> K[Waker组件通知执行器];
K --> L[执行器调度异步任务1并调用poll方法];
L --> M[异步任务1产生值];
表格
| 组件 | 功能 |
|---|---|
| Tokio 运行时 | 管理异步任务，调度任务到处理器执行 |
| 反应器（reactor） | 监听内核事件，与其他组件通信 |
| 执行器（executor） |
驱动 Future 到完成，调用
poll
方法
|
| Waker 组件 | 通知执行器 Future 已准备好继续执行 |
深入探索 Rust 异步编程
6. 异步编程适用场景分析
在实际开发中，判断一个程序是否适合使用异步编程至关重要。以下是不同类型程序的分析：
-
I/O 密集型程序
：这类程序的执行速度主要受限于 I/O 操作，如网络请求、文件读写等。在等待 I/O 操作完成时，CPU 处于空闲状态，而异步编程可以利用这段时间执行其他任务，提高整体效率。例如，Web 服务器需要处理大量并发请求，使用异步编程可以显著提升响应速度。
-
CPU 密集型程序
：程序的执行速度主要取决于 CPU 的处理能力，如复杂的数值计算、图形处理等。在这种情况下，异步编程并不能带来明显的性能提升，因为 CPU 始终处于忙碌状态，没有空闲时间执行其他任务。
| 程序类型 | 特点 | 适合异步编程 |
|---|---|---|
| I/O 密集型 | 执行速度受限于 I/O 操作 | 是 |
| CPU 密集型 | 执行速度取决于 CPU 处理能力 | 否 |
7. 异步编程与多线程编程对比
异步编程和多线程编程都可以实现并发执行，但它们有不同的特点和适用场景。
-
异步编程
：在单个线程上通过事件驱动的方式处理多个任务，避免了线程切换的开销，适合处理大量 I/O 密集型任务。
-
多线程编程
：通过创建多个线程来并行执行任务，适合处理 CPU 密集型任务。但线程的创建和销毁会带来一定的开销，并且线程之间的同步和通信也需要额外的处理。
以下是一个简单的对比表格：
| 编程方式 | 优点 | 缺点 | 适用场景 |
| ---- | ---- | ---- | ---- |
| 异步编程 | 低开销，适合大量 I/O 任务 | 代码复杂度较高 | I/O 密集型程序 |
| 多线程编程 | 适合 CPU 密集型任务 | 线程创建和销毁开销大，同步复杂 | CPU 密集型程序 |
8. 异步编程中的错误处理
在异步编程中，错误处理是一个重要的问题。由于异步任务的执行是延迟的，错误可能在任务执行的不同阶段出现。Rust 提供了
Result
和
Option
类型来处理错误。
以下是一个简单的示例：
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use std::thread::sleep;
use std::time::Duration;
enum MyError {
Timeout,
// 可以添加更多错误类型
}
struct ReadFileFuture {}
impl Future for ReadFileFuture {
type Output = Result<String, MyError>;
fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
// 模拟超时错误
Err(MyError::Timeout).into()
}
}
#[tokio::main]
async fn main() {
let future = ReadFileFuture {};
match future.await {
Ok(result) => println!("Result: {}", result),
Err(err) => match err {
MyError::Timeout => println!("Error: Timeout"),
},
}
}
在这个示例中，
ReadFileFuture
返回一个
Result<String, MyError>
类型，表示可能成功返回一个字符串，也可能返回一个错误。在
main
函数中，使用
match
语句来处理不同的结果。
9. 异步编程的性能优化
为了提高异步程序的性能，可以采取以下措施：
-
减少阻塞操作
：尽量避免在异步代码中使用阻塞操作，如
std::thread::sleep
，可以使用异步的定时器代替。
-
合理使用并发
：根据系统资源和任务特点，合理设置并发任务的数量，避免过度并发导致性能下降。
-
优化 I/O 操作
：使用高效的 I/O 库和方法，减少 I/O 操作的时间。
10. 总结与展望
通过本文，我们全面了解了 Rust 异步编程的各个方面，包括基础知识、Futures 的工作原理、Tokio 组件的协同工作以及错误处理和性能优化等。异步编程在处理 I/O 密集型任务时具有显著的优势，可以提高程序的性能和响应速度。
在未来的开发中，随着 Rust 生态系统的不断发展，异步编程将会在更多领域得到应用。同时，我们也需要不断学习和实践，掌握更多的异步编程技巧，以应对日益复杂的开发需求。
流程图
graph TD;
A[开始] --> B{是否为 I/O 密集型任务};
B -- 是 --> C[使用异步编程];
B -- 否 --> D{是否为 CPU 密集型任务};
D -- 是 --> E[使用多线程编程];
D -- 否 --> F[根据具体情况选择];
C --> G[编写异步代码];
E --> H[编写多线程代码];
G --> I[错误处理];
H --> I;
I --> J[性能优化];
J --> K[结束];
列表
- 异步编程适合处理 I/O 密集型任务，能提高程序性能。
- 多线程编程适合处理 CPU 密集型任务，但有线程开销。
-
错误处理在异步编程中很重要，可使用
Result和Option类型。 - 性能优化可从减少阻塞操作、合理使用并发和优化 I/O 操作入手。
扫一扫
646
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
