2

假设我有这样的事情，

async fn do_update() {
    // here we store it.
    let task = task::spawn(async {
        let duration = Duration::from_millis(10);
        let mut stream = tokio::time::interval(duration);
        stream.tick().await;
        loop {
            println!("Foo");
            stream.tick().await;
        }
    });
    // and here we await it.
    task.await;
}

如果我这样称呼它，就像do_update().await循环永远运行一样。这就是我想要的。但我不希望它成为唯一运行的东西。我只是希望它阻止终止，直到任务解决。

我希望一个事件每 5 秒运行一次，而不会阻塞程序的其余部分。如果我把它放在程序的末尾，这完全符合我的要求。似乎这曾经完成过shutdown_on_idle，但现在提供的解决方案对我无效，原因与此评论相同，

我不能那样实现它，因为我在另一个任务中产生。

在任务产生任务的系统中，我如何确保只有在没有更多任务运行时才关闭可执行文件？

4

1 回答 1

0

我认为您正在寻找结构化并发，特别是全局隐式范围。可悲的是，没有人能找到一个好的解决方案，所以暂时放弃了这方面的工作。

同时，这是一种可能的解决方法。调用spawn_keep_alive而不是tokio::spawn任何应该使程序保持活动状态的任务：

操场

use parking_lot::Mutex;
use std::{
    future::Future,
    sync::atomic::{AtomicU32, Ordering},
    time::Duration,
};
use tokio::{sync::oneshot, task::JoinHandle};

static KEEPALIVE_COUNT: AtomicU32 = AtomicU32::new(0);
static KEEPALIVE_SENDER: Mutex<Option<oneshot::Sender<()>>> = parking_lot::const_mutex(None);

pub fn spawn_keep_alive<T>(task: T) -> JoinHandle<T::Output>
where
    T: Future + Send + 'static,
    T::Output: Send + 'static,
{
    KEEPALIVE_COUNT.fetch_add(1, Ordering::Relaxed);
    tokio::spawn(async {
        let result = task.await;
        if KEEPALIVE_COUNT.fetch_sub(1, Ordering::Relaxed) == 1 {
            let sender = KEEPALIVE_SENDER.try_lock().unwrap().take().unwrap();
            sender.send(()).unwrap();
        }
        result
    })
}

async fn do_update() {
    let mut stream = tokio::time::interval(Duration::from_millis(100));
    stream.tick().await;
    for _ in 0..10 {
        println!("Foo");
        stream.tick().await;
    }
    spawn_keep_alive(async {
        tokio::time::sleep(Duration::from_millis(1000)).await;
        println!("I'm aliveeee!");
    });
    spawn_keep_alive(async {
        tokio::time::sleep(Duration::from_millis(2000)).await;
        println!("Don't forget about me!");
    });
}

#[tokio::main]
async fn main() {
    let (send, recv) = oneshot::channel();
    *KEEPALIVE_SENDER.try_lock().unwrap() = Some(send);
    spawn_keep_alive(do_update());
    // Wait for all keep-alive tasks to finish
    recv.await.unwrap();
}

（KEEPALIVE_SENDER可能效率更高，但只使用了两次）。

于 2021-04-08T07:32:40.707 回答