Question

考虑以下异步功能：

async fn call_me<F>(f : F ) -> Result<(), Error> 
where F : FnOnce() -> Result<(), Error> {
    f()
}

有什么方法可以延迟执行内部 f()吗？

std::thread::sleep(std::time::Duration::from_millis(...)会将当前线程设置为睡眠状态，
tokio::time::delay_for(..)仅可用于异步上下文
异步关闭仍然是unstable

Answer 1

与异步闭包非常相似的是一个闭包，它返回一个Future（恰好是异步块）

async fn call_me<F, Fut>(f: F) -> Result<(), ()>
where
    F: FnOnce() -> Fut,
    Fut: Future<Output = Result<(), ()>>,
{
    f().await
}

#[tokio_macros::main]
async fn main() {
    call_me(|| async {
        tokio::time::delay_for(std::time::Duration::from_secs(10)).await;
        Ok(())
    })
    .await
    .unwrap();
}

Answer 2

解决方案是直接传递std::future::Future：

async fn call_me(f : Future) -> Result<(), Error) {
    tokio::time::timeout(tokio::time::Duration(1_000), f()).await
}

async fn some_async_function() -> Result<(), Error> {
   tokio::time::delay_for(tokio::time::Duration::from_millis(10_000).await;
   Ok(()
}

#[tokio:main]
async fn main() {
   call_me(some_async_function()).await;
}

如何在异步函数调用的闭包内部延迟执行？

2 个答案: