Rust 什么是未来：：未来：：懒惰？_Rust_Future_Rust Tokio

Rust 什么是未来：：未来：：懒惰？

rust

Rust 什么是未来：：未来：：懒惰？,rust,future,rust-tokio,Rust,Future,Rust Tokio,在中，我们有以下片段：外部板条箱东京；外部板条箱期货；使用futures:：future:：lazy；东京：runlazy | |{ 因为我在0..4{ tokio:：spawnlazymove | |{ println！你好，来自任务{}，我；好啊 }; } 好啊 }; 对此的解释是：第一次轮询future时，lazy函数运行闭包。这里使用它来确保从任务调用tokio:：spawn。如果没有lazy，将从任务上下文之外调用tokio:：spawn，这将导致错误尽管我对东京有一些熟

在中，我们有以下片段：

外部板条箱东京；外部板条箱期货；使用futures:：future:：lazy；东京：runlazy | |{ 因为我在0..4{ tokio:：spawnlazymove | |{ println！你好，来自任务{}，我；好啊 }; } 好啊 }; 对此的解释是：

第一次轮询future时，lazy函数运行闭包。这里使用它来确保从任务调用tokio:：spawn。如果没有lazy，将从任务上下文之外调用tokio:：spawn，这将导致错误

尽管我对东京有一些熟悉，但我不确定自己是否准确地理解了这一点。似乎这两个懒人的角色略有不同，而这种解释只适用于第一个。在for循环中对lazy的第二次调用不正是为了将闭包转换为未来吗？

lazy的用途包括：

创建一个新的未来，最终将与所提供的闭包所创建的未来相同

提供的闭包只有在future上安排了回调后才会运行，否则回调永远不会运行。然而，一旦运行，这个未来与闭包创建的未来是一样的

与普通闭包一样，它用于防止代码被急切地评估。在同步术语中，调用函数和调用函数返回的闭包之间的区别在于：

fn sync() -> impl FnOnce() {
    println!("This is run when the function is called");
    
    || println!("This is run when the return value is called")
}

fn main() {
    let a = sync();
    println!("Called the function");
    a();
}

与期货0.1相比：

use futures::{future, Future}; // 0.1.27

fn not_sync() -> impl Future<Item = (), Error = ()> {
    println!("This is run when the function is called");

    future::lazy(|| {
        println!("This is run when the return value is called");
        Ok(())
    })
}

fn main() {
    let a = not_sync();
    println!("Called the function");
    a.wait().unwrap();
}

如您所知，Tokio的示例使用lazy来：

确保闭包中的代码仅从执行器内部运行。确保关闭是作为将来的一种方式运行的我认为懒惰的这两个方面实际上是一样的

另见：

懒惰的目的包含在以下内容中：