FuturesUnordered 的生命周期问题

Question

我试图将这些Readable实例存储在Coordinator结构上，并有一个schedule方法可以选择其中一个实例readables并将其推送到 FuturesUnordered 实例（也在 内部Coordinator）中以便稍后提取。问题是：由于生命周期错误，这无法编译

use bytes::Bytes;
use futures::prelude::stream::FuturesUnordered;
use std::future::Future;
use std::pin::Pin;

struct Readable {}

impl Readable {
    async fn read(&mut self) -> Result<Bytes, ()> {
        Err(())
    }
}

type Futures = FuturesUnordered<Pin<Box<dyn Future<Output = Result<Bytes, ()>> + Send>>>;

struct Coordinator {
    readers: Vec<Readable>,
    futures: Futures,
}

impl Coordinator {
    fn schedule(&mut self) {
        let reader = self.readers.get_mut(0).unwrap();
        let f = Box::pin(reader.read());
        self.futures.push(f);
    }
}

错误

error[E0759]: `self` has an anonymous lifetime `'_` but it needs to satisfy a `'static` lifetime requirement
  --> src/lib.rs:23:22
   |
22 |     fn schedule(&mut self) {
   |                 --------- this data with an anonymous lifetime `'_`...
23 |         let reader = self.readers.get_mut(0).unwrap();
   |                      ^^^^^^^^^^^^ ...is captured here...
24 |         let f = Box::pin(reader.read());
25 |         self.futures.push(f);
   |                           - ...and is required to live as long as `'static` here

error: aborting due to previous error

链接到游乐场：https://play.rust-lang.org/? version=stable&mode=debug&edition=2018&gist=2b69f519de1ac60b30bbbfb4a3cc3b7d

任何人都可以帮助我理解为什么这是一个问题？具体来说，当我尝试推送FuturesUnordered但我没有看到推送方法有任何生命周期界限时，它似乎在抱怨：

    /// Push a future into the set.
    ///
    /// This method adds the given future to the set. This method will not
    /// call [`poll`](core::future::Future::poll) on the submitted future. The caller must
    /// ensure that [`FuturesUnordered::poll_next`](Stream::poll_next) is called
    /// in order to receive wake-up notifications for the given future.
    pub fn push(&self, future: Fut) {...}

我认为它也可能与具有自引用的特定结构有关（即：Coordinator::futures正在引用Coordinator::readers），但我不完全理解这是否相关。

Answer 1

如果我们扩展异步函数，它将如下所示：

fn read<'a>(&'a mut self) -> impl Future<Output = Result<Bytes, ()>> + 'a 

正如您所看到的，生命周期'a已在返回Future类型中捕获，这'a是一个匿名生命周期，因为read可以从任何位置调用该函数。

这导致了我们的问题；从编译器的角度来看，您的schedule函数创建了一个具有匿名生命周期的 future，并尝试将其存储在self. 即使您像这样存储您的未来，编译器仍然会抛出相同的错误，这与它无关。 FuturesUnorderedself.futures = f

一种解决方案可以使用专用生命周期来告诉编译器这是安全的，但我并不真正建议这样做，因为最终它可能会导致任何其他问题，因为它强制在特定生命周期中借用 self，如下面的代码所示。

impl<'a> Coordinator<'a> {
    fn schedule(&'a mut self) {//forced
        let reader = self.readers.get_mut(0).unwrap();
        let f = Box::pin(reader.read());
        self.futures = f;
    }
}

操场

如果您的未来不借用任何东西，其他解决方案会更容易，您可以定义没有生命周期的异步函数作为未来的构建者。

impl<'a> Coordinator<'a> {
    fn schedule(&'a mut self) {//forced
        let reader = self.readers.get_mut(0).unwrap();
        let f = Box::pin(reader.read());
        self.futures = f;
    }
}

操场

也可以看看 ：

• https://rust-lang.github.io/rfcs/2394-async_await.html#lifetime-capture-in-the-anonymous-future
• 从 `async fn` 返回的 future 的具体类型是什么？