Rust 异步编程，async await

 

 应用:简单HTTP服务器

 

 https://learnku.com/docs/async-book/2018/http_server_example/4789

 

 

 

//例子二
use futures::{ self, executor};

async fn learn_song() {
    println!("Learn song!");
}

async fn sing_song() {
    println!("Sing song!");
}

async fn dance() {
    println!("Dance!");
}

async fn learn_and_sing_song() {
    learn_song().await;
    sing_song().await;
}

async fn async_main() {
    let f1 = learn_and_sing_song();
    let f2 = dance();
    futures::join!(f1, f2);
}
fn main() {
    executor::block_on(async_main());
    println!("Hello, world!");
}

 

简写!这里需要注意的是println!非println，多了感叹号!，后缀不带感叹号为普通函数，带感叹号的为宏函数，rust不存在println普通函数。

 

宏的参数可以用方括号包围

C语言带参数的宏，其参数使用圆括号包围。Rust也可以使用圆括号包围参数，但是Rust的宏还可以用方括号包围，如：

let v = vec![1, 2, 3, 4, 5];

root@bogon async2]# cargo build
   Compiling own v0.1.0 (/data2/rust/async2)
    Finished dev [unoptimized + debuginfo] target(s) in 0.62s
[root@bogon async2]# cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.03s
     Running `target/debug/own`
Learn song!
Sing song!
Dance!
Hello, world!
[root@bogon async2]# cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.03s
     Running `target/debug/own`
Learn song!
Sing song!
Dance!
Hello, world!
[root@bogon async2]# 

 

 

 

 

 

 

作用
async/.await 是 Rust 编写异步的内置工具。async 将一个代码块转化为实现了 future 特征的状态机。
那么，转化为 future 后有什么作用呢？答案：在同步方法中调用阻塞函数（async 转化的函数）会阻塞整个线程，但是，阻塞的 future 会让出线程控制权，允许其它 future 运行。

部分语法
准备工作：配置文件 Cargo.toml

[dependencies]
futures = "0.3.4"
创建异步函数

创建异步函数的语法：

async fn my_function() {
println!("Hello");
}
通过 async 关键字，上面的函数返回一个 Future。换句话说，上面的函数等价于如下代码：

fn my_function() -> impl Future<Output = ()> {
async {
println!("Hello");
}
}
调用异步函数
上面简介绍了创建异步函数的语法，下面我们看下如何调用异步函数。

（１）通过 block_on 阻塞调用

//例子一
use futures::executor;

async fn my_function() {
println!("Hello");
}

fn main() {
let f = my_function();
executor::block_on(f);
}
（２）通过.await 调用

//例子二
use futures::{ self, executor};

async fn learn_song() {
println!("Learn song!");
}

async fn sing_song() {
println!("Sing song!");
}

async fn dance() {
println!("Dance!");
}

async fn learn_and_sing_song() {
learn_song().await;
sing_song().await;
}

async fn async_main() {
let f1 = learn_and_sing_song();
let f2 = dance();
futures::join!(f1, f2);
}
fn main() {
executor::block_on(async_main());
println!("Hello, world!");
}
说明：

a、在 learn_and_sing_song () 中，会先执行 learn_song ()，然后再执行 sing_song ()，两者按照顺序执行；

b、通过 join，能等待多个 Future 完成；

c、当 await 发生阻塞时，不会阻塞当前线程，可以让其它的任务执行（在此例子中，如果在 learn_song 阻塞，则 learn_and_sing_song 会让出当前线程，可以让 dance 执行）。

总结
本节主要简单介绍 async/await 在异步函数方面的用法，同时通过 sing、song、dance 的例子，展示了 async 的应用。

但是，本例子中只是简单的语法展示，并不能真正达到我们想要的异步效果。

那么，为什么无法达到我们想要的效果，请持续关注我们 Rust 异步编程的学习笔记。