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));
//     }
// }
相关推荐
小喷友9 小时前
阶段三:进阶(Rust 高级特性)
前端·rust
Python私教11 小时前
源滚滚Rust全栈班v1.02 无符号整数详解
开发语言·后端·rust
专注VB编程开发20年1 天前
CSS 的命名方式像是 PowerShell 的动词-名词结构,缺乏面向对象的层级关系
开发语言·后端·rust
伍哥的传说1 天前
Tailwind CSS v4 终极指南:体验 Rust 驱动的闪电般性能与现代化 CSS 工作流
前端·css·rust·tailwindcss·tailwind css v4·lightning css·utility-first
专注VB编程开发20年1 天前
rust语言-对象多级访问
服务器·前端·rust
编码浪子1 天前
趣味学RUST基础篇(构建一个命令行程序2重构)
开发语言·重构·rust
susnm1 天前
组件生命周期
rust·全栈
bruce541101 天前
Axum 最佳实践:如何构建优雅的 Rust 错误处理系统?(三)
rust
Source.Liu2 天前
【Python基础】 15 Rust 与 Python 基本类型对比笔记
笔记·python·rust
咸甜适中2 天前
rust语言 (1.88) egui (0.32.1) 学习笔记(逐行注释)(二十六)windows平台运行时隐藏控制台
笔记·学习·rust·egui