Asynchronous 如何实现轮询异步fn的未来或流？

我有一个struct

Test

我想实现

std:：future:：future

，它将轮询

函数

：

使用std:：{
未来，
pin：：pin，
任务：：{Context，Poll}，
};
结构测试；
impl试验{
异步fn函数（&mut self）{}
}
impl测试的未来{
类型输出=（）；
fn轮询（self:Pin、cx:&mut Context src/lib.rs:17:13
|
10 |异步fn函数（&mut self）{
|-此'async fn'的'Output'应为不透明类型
...
17 | Poll:：Pending=>Poll:：Pending，
|^^^^^^^^^^^^^^^^^应为不透明类型，找到enum`Poll`
|
=注意：预期不透明类型为'impl Future`
找到enum`Poll`
错误[E0308]：类型不匹配
-->src/lib.rs:18:13
|
10 |异步fn函数（&mut self）{
|-此'async fn'的'Output'应为不透明类型
...
18 | Poll:：Ready（）=>Poll:：Ready（（）），
|^^^^^^^^^^^^^^^^^^^应为不透明类型，找到枚举`轮询`
|
=注意：预期不透明类型为'impl Future`
找到enum`Poll`

我知道

函数

必须调用一次，返回的

未来

必须存储在结构中的某个位置，然后必须轮询保存的未来。我尝试了以下方法：

struct测试（可选）；
impl试验{
异步fn函数（&mut self）{}
fn new（）->Self{
设mut s=Self（无）；
s、 0=一些（Box:：pin（s.function（））；
s
}
}

这也不起作用：

error[E0277]：编译时无法知道类型为`（dyn Future+'static）`的值的大小
-->src/lib.rs:7:13
|
7 |结构测试（可选）；
|^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^在编译时没有已知的大小
|
=帮助：未为`（dyn Future+'静态）实现特征'Sized'`

调用

function（）

后，我对

Test

进行了

&mut

引用，因此无法更改

Test

变量，因此无法将返回的

Future

存储在

Test

中

我确实得到了一个不安全的解决方案（灵感来自）

struct-Test>）；
impl-Test我不确定您想要实现什么以及为什么，但我怀疑您试图基于一些古老的教程或误解实现
Future-for-Test
，只是将事情过度复杂化了

您不必手动实现
Future
。一个
async
函数

异步fn函数（…）{…}

真的只是语法糖在幕后被翻译成

fn函数（…）->Future{…}

您所要做的就是以与将来相同的方式使用函数的结果，例如使用wait on或调用block a reactor直到完成。例如，根据您的第一个版本，您只需调用：

让mut test=test{}；
test.function（）.wait；

更新1

根据您的描述，我仍然认为您试图将这个最小的工作片段过度复杂化，而无需手动实现

Future

：

async fn asyncio（）{println！（“执行异步IO”）；}
结构测试{
计数：u32，
}
impl试验{
异步fn函数（&mut self）{
asyncio（）。等待；
self.count+=1；
}
}
#[tokio:：main]
异步fn main（）{
设mut test=test{count:0}；
test.function（）.wait；
println！（“计数：{}”，test.Count）；
}

我不确定您想要实现什么以及为什么，但我怀疑您正试图基于一些古老的教程或误解实现

未来测试

，并且只是将事情过度复杂化了

您不必手动实现

Future

。一个

async

函数

异步fn函数（…）{…} 真的只是语法糖在幕后被翻译成

fn函数（…）->Future{…}

您所要做的就是以与将来相同的方式使用函数的结果，例如使用wait on或调用block a reactor直到完成。例如，根据您的第一个版本，您只需调用：

让mut test=test{}；
test.function（）.wait；

更新1

根据您的描述，我仍然认为您试图将这个最小的工作片段过度复杂化，而无需手动实现

Future

：

async fn asyncio（）{println！（“执行异步IO”）；}
结构测试{
计数：u32，
}
impl试验{
异步fn函数（&mut self）{
asyncio（）。等待；
self.count+=1；
}
}
#[tokio:：main]
异步fn main（）{
设mut test=test{count:0}；
test.function（）.wait；
println！（“计数：{}”，test.Count）；
}

虽然有时您可能想做一些类似于您在这里尝试完成的事情，但这是非常罕见的。因此，阅读本文的大多数人，甚至可能是OP，可能希望重新构造结构，以便用于单个异步执行的结构状态和数据是不同的对象

回答您的问题，是的，这在某种程度上是可能的。除非您想绝对使用不安全的代码，否则您需要使用和。您希望在

async fn

中操作的所有字段都必须包装在

互斥体中，并且函数本身将接受
Arc

然而，我必须强调，这不是一个很好的解决方案，您可能不想这样做。根据您的具体情况，您的解决方案可能会有所不同，但我对OP在使用
流时试图实现的目标的猜测最好是通过类似的方法来解决

使用std:：{
未来，
pin：：pin，
sync:：{Arc，Mutex}，
};
结构测试{
状态：互斥体，
//如果可用，请使用异步库的互斥锁来`.wait`锁定