Rust- async/await

async and await are key language features in Rust for writing asynchronous code. They were stabilized in the Rust 1.39.0 release.

Asynchronous programming is a way of writing programs that are able to do multiple things at the same time. It's particularly useful in situations where you need to handle many tasks at once, or when you have IO-bound tasks (like network requests) that often spend a lot of time waiting.

Here's how async and await work in Rust:

  • async : The async keyword in Rust is used to define an asynchronous function that returns a future. A future is a value that represents some computation that will complete in the future.

    Here is a simple async function:

    rust 复制代码
    async fn hello() {
        println!("Hello, async world!");
    }

    This hello function, when called, will produce a future. To actually execute the code inside the function, the future needs to be run on an executor.

  • await : The await keyword is used within async functions to wait for the result of a future. Unlike blocking in a traditional function, awaiting inside an async function allows other tasks to run.

    Here is an example of using await:

    rust 复制代码
    async fn hello() -> String {
        "Hello, async world!".to_string()
    }
    
    #[tokio::main] // or #[async_std::main] if you're using async-std
    async fn main() {
        let message = hello().await;
        println!("{}", message);
    }

    In this example, hello().await causes the main function to wait for the hello function to finish, and then binds its result to the message variable.

Rust's async system works on a zero-cost abstraction principle, which means there should be no additional overhead for using these features.

Note that Rust's standard library does not provide an async runtime. You'll need to use a crate like tokio or async-std to provide an executor and other tools for working with async functions and futures. These are powerful libraries that provide async versions of many standard Rust features, along with additional tools for building async applications.

rust 复制代码
use async_std::task::{sleep, spawn, block_on};
use std::{future::Future, time::Duration};

#[async_std::main]
async fn main() {
    // do3();
    // do4();

    // let do3_span = spawn(do3);
    // let do4_span = spawn(do4);

    // do3_span.join().unwrap();
    // do4_span.join().unwrap();

    // let do3_async = spawn(do3());
    // do4().await;
    // do3_async.await;

    let result = block_on(rust_study());
    println!("{}", result);     // Rust 学习目标:Programming
}

async fn lesson() -> String {
    String::from("Rust")
}

fn study1() -> impl Future<Output = String> {
    async {
        let x = lesson().await;
        x + " 学习目标:"
    }
}

fn rust_study() -> impl Future<Output = String> {
    let r = |x: String| async move {
        let y: String = study1().await;
        y + &*x
    };
    r(String::from("Programming"))
}

async fn do3() {
    for i in 1..=5 {
        println!("do3 {}", i);
        sleep(Duration::from_millis(500)).await;
    }
}

async fn do4() {
    for i in 1..=5 {
        println!("do4 {}", i);
        sleep(Duration::from_millis(1000)).await;
    }
}

// fn do3() {
//     for i in 1..=5 {
//         println!("do3 {}", i);
//         sleep(Duration::from_millis(500));
//     }
// }

// fn do4() {
//     for i in 1..=5 {
//         println!("do4 {}", i);
//         sleep(Duration::from_millis(1000));
//     }
// }
相关推荐
梦想画家12 小时前
快速解锁Rust Slice特性
开发语言·rust·slice
良技漫谈13 小时前
Rust移动开发:Rust在iOS端集成使用介绍
后端·程序人生·ios·rust·objective-c·swift
monkey_meng16 小时前
【Rust实现命令模式】
开发语言·设计模式·rust·命令模式
Dontla16 小时前
《Rust语言圣经》Rust教程笔记17:2.Rust基础入门(2.6模式匹配)2.6.2解构Rust Option<T>
笔记·算法·rust
Source.Liu1 天前
【用Rust写CAD】前言
开发语言·rust
良技漫谈1 天前
Rust移动开发:Rust在Android端集成使用介绍
android·程序人生·rust·kotlin·学习方法
大鲤余1 天前
rust 中if let、match -》 options和Result枚举类型
开发语言·后端·rust
Source.Liu1 天前
【用Rust写CAD】第二章 第一节 Rust注释
开发语言·rust
喜欢打篮球的普通人1 天前
2024 Rust现代实用教程 closures闭包
rust
Aaaaaaaaaaayou2 天前
从零实现 webpack,但 Rust 版 - [4] 实现插件系统
webpack·rust