异步理解之路一

参考博客：https://hegdenu.net/posts/understanding-async-await-1/

tokio::time::sleep(std::time::Duration::from_millis(100));
// 这不会 sleep。编译器会立即警告你这行不通
= note: futures do nothing unless you `.await` or poll them
// 会 sleep
tokio::time::sleep(std::time::Duration::from_millis(100)).await;

async fn hello(name: &'static str) {
    println!("hello, {name}!");
}

#[tokio::main]
async fn main() {
    hello("world").await;
}
// hello, world!

enum Hello {
    Init {name: &'static str},
    Done,
}

1. 简而言之，Hello 枚举被构造成 Init 状态
2. 调用 poll() 将其转换为 Done 状态
3. 对象现在只能被丢弃（drop）
4. 这可能还没有意义。但它应该有助于理解代码。这还不是 future，所以我们不能 await。为了解决这个问题，我们需要实现 Future trait

pub enum Poll<T> {
    Ready(T),
    Pending,
}

1. 当 future 有一个值要返回时，它返回 Ready(T)，这里，T 是 Future 的关联类型 Output

impl Future for Hello {
    type Output = ();
    fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
        match *self {
            Hello::Init { name } => println!("hello, {name}!"),
            Hello::Done => panic!("Please stop polling me!"),
        };
        *self = Hello::Done;
        Poll::Ready(())
    }
}

1. 如果我们处于初始状态 Init，那么输出 hello， {name} !，这是 async 函数的主体
2. 如果我们处于完成状态，我们就会恐慌
3. 在 match 语句之后，我们将状态设置为 Done。最后，我们返回 Ready(())。记住，一个不返回任何东西的函数，实际上返回的是单位类型 ()

1. This future is very simple，It will become ready on the first poll
2. 但如果事实并非如此呢？这就是 Poll::Pending 使用的地方，稍后我们将讨论如何使用 Pending

我们需要构建新的 future 来使用它，让我们把它封装在一个函数中，就像我们的 async 函数一样

fn hello(name: &'static str) -> impl Future<Output = ()> {
    Hello::Init { name }
}

1. 关于这个函数，我们注意到的第一件事是它没有标记为 async，因为我们返回的是“手工制作”的 future，所以不能使用 async 关键字，而是返回 impl Future
2. 那么函数体呢？构造枚举的 Init 变体并返回它。现在开始清楚了，如果不 await，为什么 async 函数什么也不做。我们什么都没做！只是构造一个对象，不会运行其他东西。所以 call our future，我们不能调用 poll()，我们没有 Context 传递给它。我们可以创建一个上下文，但那是另一个故事了。记住，我们想了解 async/await 是如何为用户工作的，而不是为异步运行时工作的

use std::future::Future;
use std::task::{Context, Poll};
use std::pin::Pin;
enum Hello {
    Init {name: &'static str},
    Done,
}
impl Future for Hello {
    type Output = ();
    fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
        match *self {
            Hello::Init { name } => println!("hello, {name}!"),
            Hello::Done => panic!("Please stop polling me!"),
        };
        *self = Hello::Done;
        Poll::Ready(())
    }
}
fn hello(name: &'static str) -> impl Future<Output = ()> {
    Hello::Init { name }
}
fn main() {
    let myfuture = hello("hbj");
    // 不能调用 poll 方法，只是构造了一个有 future 特征的对象
    // myfuture.poll();
}

1. 幸运的是，await 关键字在“手工制作”的 futures 中工作得很好。毕竟，这是编译器在底层创建的东西。因此，让我们 await 我们的 future

use std::future::Future;
use std::task::{Context, Poll};
use std::pin::Pin;
enum Hello {
    Init {name: &'static str},
    Done,
}
impl Future for Hello {
    type Output = ();
    fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
        match *self {
            Hello::Init { name } => println!("hello, {name}!"),
            Hello::Done => panic!("Please stop polling me!"),
        };
        *self = Hello::Done;
        Poll::Ready(())
    }
}
fn hello(name: &'static str) -> impl Future<Output = ()> {
    Hello::Init { name }
}
// fn main() {
//     let myfuture = hello("hbj");
//     // 不能调用 poll 方法
//     myfuture.poll();
// }
#[tokio::main]
async fn main() {
    hello("world").await;
}
PS D:\Rust\Work_Place\hello_work> cargo run
   Compiling hello_work v0.1.0 (D:\Rust\Work_Place\hello_work)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.71s
     Running `target\debug\hello_work.exe`
hello, world!