在另一个轮询中轮询上下文

Question

我有一个轮询 function，它将永远轮询并始终挂起。 在轮询 function poll_event_loop中，我想控制再次轮询上下文的时间，并根据某些条件在x秒内再次调用 function。 我可以使用另一个调用waker.wake_by_ref function 的线程来做到这一点。但这感觉像是作弊。 如果没有其他线程，我怎么能做到这一点。

poll_fn(|cx| self.poll_event_loop(cx)).await

// function will never be  Ready, always pending, polling sould be fast so not just sleeping x seconds inside
fn poll_event_loop(&mut self, cx: &mut Context) -> Poll<anyhow::Result<()>> {
    while some_codeandfunc() { /*....*/ }

    // guarantee another poll_fn in 1 sec
    if condition {
        context_callback(cx, 1000);
    }

    // guarantee another poll_fn in 2 sec
    if condition {
        context_callback(cx, 2000);
    }

    Poll::Pending
}

fn context_callback(context: &mut Context, millisec: u64) {
    let mut future = Box::pin(tokio::time::sleep(Durationtk::from_millis(millisec)));
    //let cb = future.as_mut().poll(context);
    future.poll_unpin(context);
}

//  ugly way to auto poll the function every x seconds
fn spawn_qeueu_thread(waker: &Waker, rx: &Receiver<String>) -> Option<JoinHandle<()>> {
    debug!("doing spawning thread");
    //self.thread_spawned = true;
    let waker = waker.clone();
    let rx2 = rx.clone();
    let spawn = tokio::spawn(async move {
        loop {
            tokio::time::sleep(Durationtk::from_millis(WAKEUPINTERVAL)).await;
            debug!("doing other thread wakebyref");
            waker.wake_by_ref();
            let try_result = rx2.try_recv();
            match try_result {
                Err(_) => {}
                Ok(_msg) => break,
            }
        }
        debug!("ending spawned thread");
    });
    return Some(spawn);
    //self.threadhandle = Some(spawn);
}

Answer 1

经过一些试验，我找到了一个可行的解决方案，可以让您在多个所需时间调用轮询 function，工作示例：

use chrono::Utc;
use futures::FutureExt;
use futures::future::poll_fn;
use tokio::time::Sleep;
use std::pin::Pin;
use std::task::Context;
use std::task::Poll;
use tokio::time::Duration as Durationtk;

pub struct ControllerModule {
    vec: Vec<Pin<Box<Sleep>>>,
    i: i64,
}

impl ControllerModule {
    fn new() -> Self {
        let vec = vec![];
        let i = 0;

        Self { vec, i }
    }
    async fn start(&mut self) {
        poll_fn(|cx| self.poll_event_loop(cx)).await;
        print!("worked");
    }

    fn poll_event_loop(&mut self, context: &mut Context) -> Poll<anyhow::Result<()>> {

        self.i += 1;

        if self.i % 3 == 0 {
            let mut sleep = Box::pin(tokio::time::sleep(Durationtk::from_millis(5000)));
            sleep.poll_unpin(context);
            self.vec.push(sleep);
        } else if self.i % 3 == 1 {
            let mut sleep = Box::pin(tokio::time::sleep(Durationtk::from_millis(4000)));
            sleep.poll_unpin(context);
            self.vec.push(sleep);
        } else {
            context.waker().wake_by_ref();
        }

        self.vec.retain(|e| !e.is_elapsed());

        Poll::Pending
    }
}

#[tokio::main]
async fn main() {
    let mut i = ControllerModule::new();
    i.start().await
}