主页 / coding / 问题 / 79118831
Accepted
Fee
Asked: 2024-10-24 00:27:06 +0800 CST

每次创建未来时，`pub fn long(&self) -> impl Future<Output = ()> + 'static` 是否会泄露数据？

  • 772

基本上，基于这个答案：

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：它说awaiting 放弃了未来
  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)
asynchronous

1 个回答

  1. Best Answer

    没有内存泄漏。堆分配的内容（如s）将在完成之前被删除.await。完成后，未来的堆栈分配将超出范围.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` (heap allocation) will be automatically dropped.
                  *self = Self::Done;
              }
              Self::Done => {}
         }
         Poll::Ready(())
    }
}

    你可以想象.await像这样实现（屈服于运行时和通过注册唤醒的复杂性Poll::Pending已async被Context省略）：

    let future = long();
// future.await;
let result = {
    // future is moved to a mutable variable
    let mut fut = future;
    loop {
        let poll = fut.poll();
        if poll.is_ready() {
            break poll;
        } else {
            unreachable!("ReturnedFuture never returns pending, so this complexity has been elided");
        }
    }
    // fut goes out of scope here (stack allocation is dropped).
};
// future no longer exists here (it was moved already)

    请参阅最后两个代码块中的注释以了解何时释放内存。

    • 2

相关问题