Rust中实现简单的异步协程

Rust本身没有提供协程，仅将async-await编译成状态机，然后使用poll方法在异步上下文中执行，下面是一个简单的异步实现。

use std::collections::VecDeque;
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll, Waker};
use std::time::{Duration, Instant};


trait Task {
    fn poll(self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<()>;
}

impl<F: Future> Task for F {
    fn poll(self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<()> {
        match self.poll(context) {
            Poll::Ready(_) => Poll::Ready(()),
            Poll::Pending => Poll::Pending,
        }
    }
}

struct Executor {
    tasks: VecDeque<Pin<Box<dyn Task>>>,
}

impl Executor {
    fn new() -> Self {
        Self {
            tasks: VecDeque::new(),
        }
    }

    fn spawn(&mut self, task: impl Task + 'static) {
        self.tasks.push_back(Box::pin(task));
    }

    fn run(&mut self) {
        loop {
            let mut task = if let Some(task) = self.tasks.pop_front() {
                task
            } else {
                break;
            };

            let mut context = Context::from_waker(Waker::noop());
            match task.as_mut().poll(&mut context) {
                Poll::Ready(()) => {
                    continue;
                }
                Poll::Pending => {
                    self.tasks.push_back(task);
                }
            }

            std::thread::sleep(Duration::from_millis(20));
        }
    }
}

struct Sleep {
    deadline: Instant,
}

impl Sleep {
    fn sleep(sconds: f32) -> Self {
        Self {
            deadline: Instant::now() + Duration::from_secs_f32(sconds),
        }
    }
}

impl Future for Sleep {
    type Output = ();

    fn poll(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Output> {
        if Instant::now() >= self.deadline {
            Poll::Ready(())
        } else {
            Poll::Pending
        }
    }
}

async fn async_main() {
    Sleep::sleep(3.0).await;
    println!("DONE")
}

fn main() {
    let mut executor = Executor::new();
    executor.spawn(async_main());
    executor.spawn(async_main());
    executor.spawn(async_main());
    executor.spawn(async_main());
    executor.run();
}

测试一下，几乎在3秒之后同时结束：

DONE
DONE
DONE
DONE
DONE

赏

非常感谢,我会继续努力的！

支付宝

微信

• 本文作者： killf
• 本文链接： https://www.killf.info/编程语言/Rust/Rust中实现简单的异步协程/
• 版权声明： 本博客所有文章除特别声明外，均采用 Apache License 2.0 许可协议。转载请注明出处！