rust - 如果我有嵌套的异步/等待调用，我应该关心累积的开销吗？

Question

我正在通过多个 channel 处理数据，每个 channel 都馈送到下一个 channel (管道处理)。我最终在顶部得到了一个 spawn，如下所示:

let future = async move {
    while let Ok(msg) = r.recv().await {
        forwarder.receive(msg).await;
    }
};
executor_pool::ExecutorPool::spawn(future).detach();

转发器 如下所示:

Forwarder {
    pub fn validate_sequence(&mut self, msg: TestMessage) -> Result<TestMessage, TestMessage>
    pub async fn handle_action(&mut self, cmd: TestMessage);
    pub async fn handle_notification(&mut self);
    pub async fn receive(&mut self, cmd: TestMessage) {
        match self.handle_config(cmd) {
            Ok(_) => (),
            Err(msg) => match self.validate_sequence(msg) {
                Ok(msg) => {
                    self.handle_action(msg).await;
                    self.handle_notification().await;
                },
                Err(msg) => panic!("{} sequence error: expecting {} not cmd {:#?}", self.header(), self.next_seq, msg),
            },
        }
    }
}

handle_action 和 handle_notification 都调用另一个 async fn 的发送者。我的担忧有两个方面。发送(或任何其他 async fn)的整个路径似乎需要一个 async/await 包装器。就我而言，我的发送深度为 3。这似乎有点难看，尤其是当我必须进行任何重构时。其次，每个级别的 async/await 是否有运行时成本，或者编译器是否足够智能以折叠这些？如果有助于使其更具体，请将其视为音频处理，其中第一阶段解码，下一个阶段进行调平，下一个阶段进行混合，最后一个阶段进行编码。

为了扩展重构问题，让我们看一下重构 for 循环。

pub async fn handle_action(&mut self, cmd: FwdMessage) {
  match cmd {
    FwdMessage::TestData(_) => {
      for sender in &self.senders {
        for _ in 0 .. self.forwarding_multiplier {                       
          sender.send(FwdMessage::TestData(self.send_count)).await.ok();
          self.send_count += 1;
        }
      }
    },
    _ => panic!("unhandled action"),
  }
}

我们不使用for 循环，而是使用iterator。然而，这将需要一个异步闭包——这是我什至还没有想出如何表达的东西。

Answer 1

只是嵌套 async 函数的行为不会引入任何开销。

async/await 语法编译成一个 Future ，它基本上是一个状态机，可以按照它的方式执行你的代码当它需要等待某事时可以暂停并稍后恢复。 async 函数和所有(静态已知的)await 的 futures 被编译到同一个 Future 中；功能边界有些消失。所以是的，编译器“足够聪明，可以将这些折叠起来”。