Rust异步编程简介
在这篇文章中将解释一些用于在Rust中实现异步编程的底层结构，同时将其与高级crate功能联系起来。
什么是异步编程？
简而言之，它允许在不等待另一个操作完成的情况下进行多个不同的操作。例如，如果你想做鸡蛋和吐司，你可以先煎鸡蛋，但你不必等到它们煎好再开始烤面包。
那么Rust是如何实现异步编程的呢？
cargo new asyncexamples --bin
[dependencies]
futures = "0.3.28"
tokio = {version = "1.27.0", features = ["full"]}
use tokio::time::{sleep, Duration};
async fn eggs() -> u8 {
println!("Proceed with expensive computation");
sleep(Duration::from_millis(1000)).await;
println!("Expensive computation is finished!");
20
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
println!("Our first Async Function!");
let x = eggs();
println!("The END!?");
Ok(())
}
Our first Async Function!The END!?
有两件事引起了我的注意，第一个是为什么没有任何print语句在异步函数运行？其次，你可能会注意到的另一件事是，eggs实际上返回了一些东西，它实现了Future trait，它的输出类型是u8。因为Async实际上只是下面代码的语法糖。
use futures::Future;
use tokio::time::{sleep, Duration};
fn eggs() -> impl Future<Output = u8> {
println!("Proceed with expensive computation");
async {
sleep(Duration::from_millis(1000)).await;
println!("Expensive computation is finished!");
20
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
println!("Our first Async Function!");
let x = eggs();
println!("The END!?");
Ok(())
}
这显示了由async关键字封装的块，它实现了Future trait类型，这就是要返回的东西！
pub trait Future {
type Output; // 这是trait返回的类型
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}Poll:Pending; // 表示任务仍在进行或等待中
Poll:Ready(Self::Output); // 表示完成
// 注意Self::Output包含我们的实际值!
poll函数用于表示异步块的状态，如果它仍在进行中，则返回Poll::Pending，否则返回Poll::Ready，并包含该异步块的返回值！
Context类型是什么？它的意思是表示“异步任务的上下文”，它被用来提供对&Waker类型对象的访问，然后用于“唤醒”当前任务！
use tokio::time::{sleep, Duration};
async fn eggs() -> u8 {
println!("Proceed with expensive computation");
sleep(Duration::from_millis(1000)).await;
println!("Expensive computation is finished!");
20
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
println!("Our first Async Function!");
let x = eggs().await;
println!("x = {x}");
println!("The END!?");
Ok(())
}
现在我已经在async eggs函数中添加了await，但是为什么我们一开始就需要添加它呢？这是因为，在Rust中，future是懒惰的，为了让它运行，我们必须调用await，稍后会调用poll函数，但是调用这个poll函数的是什么呢？
正如前面提到的，当我们调用.await时，实际上会放弃对当前线程的控制，并将其发送到某个地方。所以，我们显然需要一种方法来管理这些线程，这就是Tokio异步运行时发挥作用的地方。
Tokio有一个全局执行器，它将帮助我们运行这些异步块，并反过来做我们想要它做的计算。在此之前，我简要介绍了Waker是什么，以及他们做了些什么。我想现在是时候介绍这些对象背后的原因了。注意，执行器和唤醒器有两种实现方式。一种方法是使用分别由唤醒者和执行者调用的thread::unpark和thread::park。Thread::park意味着阻止当前线程运行，这样我们就不用等待接收消息，而可以做其他事情。Thread::unpark将被Waker对象调用，告诉执行者它已经等待了足够长的时间。另一种方法你可以使用Executor中的mspc通道和事件队列复制此功能。
假设我们现在把实现Future特性的异步块交给一个执行器。为了让执行器开始运行这个异步块直至完成，必须调用.await。一旦完成，执行器就会调用poll函数，并传入一个Context类型的对象，该对象封装了执行器创建的Waker对象。如果poll函数返回poll::Pending，那么该块还没有完成运行。因此，现在我们需要再次检查，而不是从循环中强制调用轮询函数，实际上可以使用Waker API向执行器发出任务完全完成或部分完成的信号。
use tokio::time::{sleep, Duration};
async fn eggs() -> String {
println!("Lets start cooking some eggs!");
sleep(Duration::from_millis(1000)).await;
println!("Eggs are finished!");
"Eggs!".to_string()
}
fn simple_example() {
println!("Lets make some eggs!");
let mut egg = "Raw Eggs".to_string();
// rt 是执行器
let rt = tokio::runtime::Builder::new_multi_thread()
.enable_all()
.build()
.unwrap();
// 在Tokio运行时上运行future直到完成，将其视为异步任务的起点。
rt.block_on(
// 实现future的异步块！
async {
// 调用.await将给执行器一个绿色信号，让它运行直到完成！
egg = eggs().await;
}
);
println!("{}", egg);
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
simple_example();
Ok(())
}