将AsyncRead的“self”包装起来具有匿名生命周期“' _”，但它需要满足“'static”生命周期要求

Question

将AsyncRead的“self”包装起来具有匿名生命周期“' _”，但它需要满足“'static”生命周期要求

3

我正在尝试将 AsyncRead 包装在另一个 AsyncRead 中（并对其进行一些数据处理）。但是，在尝试存储 .read() 的 Future 时，我遇到了生命周期问题：self has an anonymous lifetime '_ but it needs to satisfy a 'static lifetime requirement。

代码：

pub struct AsyncReadWrap {
    input: Pin<Box<dyn AsyncRead + 'static>>,
    future: Option<Pin<Box<dyn Future<Output = std::io::Result<usize>>>>>
}

impl AsyncReadWrap {
    pub fn new(input: impl AsyncRead + Unpin + 'static) -> AsyncReadWrap {
        AsyncReadWrap {
            input: Box::pin(input),
            future: None
        }
    }
}

impl AsyncRead for AsyncReadWrap {
    fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<std::io::Result<()>> {
        
        let mut buffer = [0u8; 2048];
        let future = self.input.as_mut().read(&mut buffer);
        self.future = Some(Box::pin(future));
       
        Poll::Pending
    }
}

我对异步操作还很陌生，感到奇怪的是在 poll 函数中没有简单的方法可以使用 await。谢谢。

- Makalone LOgman

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Ibraheem Ahmed · Accepted Answer

您不能从 poll 函数调用 await，因为 await 可能会多次调用 poll 并在其间将控制权返回执行器。单个 poll 调用只能产生一个 yield，并且只能通过另一个 poll 调用恢复。轮询和 futures 是 async/await 的构建块——在使用较低级别的实现时，您无法使用更高级别的抽象。

您当前代码的问题在于，您的结构体是自引用的。 input.read() 返回一个可能从 input 借用的 future:

// `Read` borrows from `self` and `buf`
fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self>

你不能将返回的 Future 存储在结构体中，因为在同一个结构体中同时存储值和对该值的引用是有问题的。

要创建一个 AsyncRead 包装器，你可以调用内部 AsyncRead 的 poll_read 方法。当 poll_read 返回 Ready 时，缓冲区将被读取值填充，接着你可以对其进行数据处理：

impl AsyncRead for AsyncReadWrap {
    fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>, mut buf: &mut ReadBuf<'_>) -> Poll<std::io::Result<()>> {
        match self.input.as_mut().poll_read(cx, &mut buf) {
            Poll::Ready(res) => {
                // do stuff with `buf`
                Poll::Ready(res)
            },
            Poll::Pending => Poll::Pending
        }
    }
}

在poll_read函数内执行更多的async操作将变得复杂，因为您必须跟踪您的AsyncRead实现将处于的多个状态。 async/await是对较低级别的未来状态机的抽象。如果您不一定需要实现AsyncRead，则可以完全避免较低级别的未来，并使其成为一个async方法：

pub async fn read(mut input: impl AsyncRead + Unpin) -> Vec<u8> {
    let mut buf = [0u8; 1024];
    input.read(&mut buf).await;
    // ...
    buf.to_vec()
}

如果您选择走低级路线，这里有一些有用的资源：