`pub fn long(&self) -> impl Future<Output = ()> + 'static` 是否会在每个创建的 future 中泄漏数据？

Question

基本上，建立在这个答案：

pub fn long() -> impl Future<Output = ()> + 'static {
  let s = String::from("what is the answer?");
  async move {
     // `s` gets moved into this block
     println!("{s}");
  }
}

#[tokio::main]
async fn main() {
    let future = long(); // Create the future
    future.await; // Await the future, it will complete, and `s` will be dropped
}

我的问题是这个

'static

绑定是否会在每个创建的未来中泄漏数据？或者这里的

'static

界限是否意味着特征实现必须是静态的？ （例如函数定义在内存中的位置）。到目前为止我已经：

1. 问ChatGPT：它说

   await

   ing会放弃未来
2. 书中的段落没有回答。
3. 阅读 rustonomicon 关于终身强制
4. 阅读类似问题

我主要试图概念化“静态”的需求和效果。该代码已经可以运行了。

背景

我有一个阅读器可以读取某些部分，而对于另一个部分，它可能需要在继续之前将附加数据加载到自身中。我想出的最好的办法是：

type Image = Vec<u8>;
#[async_trait]
trait Reader {
    async fn read_into_buffer(&self, offset: u32, buf: &mut [u8]) {
       sleep(2);
       buf.fill(42);
    }
}

struct Decoder<R: Reader> {
  reader: Arc<R>,
  images: HashMap<u32, Arc<Image>>,
}

impl<R> Decoder<R> {
  fn decode_chunk(&self, overview: u32, chunk: usize) -> Result<(),impl Future<Output = Vec<u8>> {
    if let Some(im) = self.images.get(overview) {
      // cheap clones because they are Arcs
      let image = im.clone()
      let r = self.reader.clone()
      async move {
        // don't mention `self` in here
        let buf = vec![0; 42];
        let offset = image[chunk];
        r.read_into_buffer(offset, buf);
        buf
      }
    } else {
        Err(())
    }
  }

  async fn load_overview(&mut self, offset: u32) {
    let buf = vec![0;42];
    self.reader.read_into_buffer(offset, buf).await;
    self.images.insert(offset, buf);
  }
}

可以这样使用：

decoder.load_overview(42).await;
let chunk_1 = decoder.decode_chunk(42, 13).unwrap(); // no await'ing
let chunk_2_err = decoder.decode_chunk(13).unwrap_err(); // chunk 13 isn't loaded
decoder.load_overview(13).await;
let chunk_2 = decoder.decode_chunk(13, 13).unwrap();
let res = (chunk_1.await, chunk_2.await)

Answer 1

不存在内存泄漏。

s

将在

await

完成之前被删除。

你可以把返回的

Future<Output = ()> + 'static

想象成一个状态机，像这样

enum

:

enum ReturnedFuture {
    Created{s: String}
    Done
}

这个

enum

，由于没有非

'static

引用而成为

'static

，像这样实现

Future

（我人为地简化了方法签名很多）：

impl Future for ReturnedFuture {
    fn poll(&mut self) -> Poll<()> {
         match self {
              Self::Created{s} => {
                  println!("{s}");
                  // Here is where `s` will be automatically dropped.
                  *self = Self::Done;
              }
              Self::Done => {}
         }
         Poll::Ready(())
    }
}

.await

只需在临时

poll

上调用

ReturnedFuture

，直到它返回

Poll::Ready

。请参阅评论，了解在此发生之前

s

究竟是如何被删除的。