如何同时等待 `JoinHandle` 和更新 `JoinHandle`？

Question

是否可以从一组 JoinHandle JoinHandle<()>任务中读取 stream 的Future并同时用新任务更新该组任务？

我目前有一个运行一些长任务的Service 。 唯一的问题是，我实际上想（如果可能的话）同时添加新任务——通过某种类型的Receiver通道发送的标志（为了简单起见，下面未显示）。

鉴于在Service::run handles中，function 拥有该句柄，我倾向于“否”，这是不可能的。 这是真的？ 如果根据我的设置这是不可能的，有什么方法可以调整下面的代码来实现这一点吗？

我在这个答案中读到，将HashMap包装在Option中允许我在Service::run中使用.take()因为需要拥有该值才能调用.into_values() 。 然而，问题在于.take()消耗了Mutex中的值，而None留在了它的身后。

这是我最小的可重现示例（没有编译这个，但应该给出想法）：

use tokio::{sleep, time::Duration, task::JoinHandle};
use async_std::{Mutex, Arc};
use futures::{
    stream::{FuturesUnordered, StreamExt},
    Future,
};

type Handles = Arc<Mutex<Option<HashMap<String, JoinHandle<()>>>>>;

fn a_task() -> impl Future<Output = ()> {
  async move {
    sleep(Duration::from_secs(3)).await;
  }
}


fn the_update_task(handles: Handles) -> impl Future<Output = ()> {
  async move {
    // would like to update `handles` here as I get new data from a channel
    // calling .take() in Service::run nukes my handles here :(
  }
}

struct Service {
  handles: Handles,
}

impl Service {
  fn new() -> Self {
    let handles = Arc::new(Mutex::new(Some(HashMap::default())));
    let handle = tokio::spawn(the_update_task(handles.clone());
    Self { handles }
  }

  async fn add_a_task(&mut self, id: String) {
    let handle = tokio::spawn(a_task());
    self.handles.lock().await.as_mut().unwrap().insert(id, handle);
  }

  async fn run(self) {
    let Service { handles, .. } = self;
    let mut futs = FuturesUnordered::from_iter(
       handles.lock().await.take().unwrap().into_values()
    );
    while let Some(fut) = futs.next().await {
      info!("I completed a task! fut:?}");
    }
  }
}

#[tokio::main]
async fn main() {
   let mut srvc = Service::new();
   srvc.add_task("1".to_string()).await;
   srvc.add_task("2".to_string()).await;

   let handle = tokio::spawn(srv.run());
   handle.await;
}

我努力了

• 使用Arc(Mutex(HashMap))
• 使用Arc(Mutex(Option(HashMap)))

我似乎总是得出同样的结论：

• 我不能同时拥有Service::run中的handles和更新代码其他部分的handles （甚至是副本/引用）

Answer 1

只是在 @user1937198 的评论的帮助下在这里回答我自己的问题。

解决方案是直接使用新任务更新对FuturesUnordered的引用，而不是关注handles 。 这大大简化了事情。

use tokio::{sleep, time::Duration, task::JoinHandle};
use async_std::{Mutex, Arc};
use futures::{
    stream::{FuturesUnordered, StreamExt},
    Future,
};

fn a_task() -> impl Future<Output = ()> {
  async move {
    sleep(Duration::from_secs(3)).await;
  }
}


fn the_update_task(futs: Arc<Mutex<FuturesUnordered>>) -> impl Future<Output = ()> {
  async move {
    // Just push another task
    let fut = tokio::spawn(a_task());
    futs.lock().await.push(fut);
  }
}

struct Service {
  handles: HashMap<String, JoinHandle<()>>,
}

impl Service {
  fn new() -> Self {
    let handles = HashMap::default();
    Self { handles }
  }

  async fn add_a_task(&mut self, id: String) {
    let handle = tokio::spawn(a_task());
    self.handles.insert(id, handle);
  }

  async fn run(self) {
    let Service { handles, .. } = self;
    let futs = Arc::new(Mutex::new(FuturesUnordered::from_iter(handles.into_values())));

    tokio::spawn(the_update_task(futs.clone())).await.unwrap();

    while let Some(fut) = futs.lock().await.next().await {
      info!("I completed a task! fut:?}");
    }
  }
}

#[tokio::main]
async fn main() {
   let mut srvc = Service::new();
   srvc.add_task("1".to_string()).await;
   srvc.add_task("2".to_string()).await;

   let handle = tokio::spawn(srv.run());
   handle.await;
}