用「async / await」语法来撰写并发与并进程式是现代编程语言流行的方式,比起传统打开新的线程来完成并发处理工作的目的,「async / await」可以在同一个线程下达到同样的目的,非常适用于当并发处理的工作并不重的时候,能够省下创建线程所产生的开支(overhead)。
作为一个 2015 年才被正式发布的编程语言,虽然 Rust 在 1.39 之后正式支持「async / await」语法,但是并没有提供标准的「异步(Asynchronous) runtime」,需要添加很多额外的 crate 来实现这项机制。
「async / await」语法
在开始介绍异步 runtime 之前,要先了解 Rust 的 async 和 .await 关键字的用法。
在程序区块的前面加上 async 关键字或是 async move 关键字,可以快速地使这个程序区块变成一个有实作 core::future::Future 特性的对象,Future 特性的 Output 关联类型会是这个程序区块的回传值类型(如果无回传值就会是 ())。例如:
let future = async {
println!("Hello, world.");
0
};
以上的 future 变量,保存着一个可以向标准输出(stdout)输出 Hello, world. 字符串,并且回传 0 的 Future 对象。
Future 对象在被创建之后,其程序区块中的叙述并不会立刻被运行。需在同样有使用 async 关键字的程序区块内使用 .await 关键字,才能够去运行它。这样的作法与 JavaScript 提供的「async / await」语法有点不一样,在 JavaScript 中,Promise 对象被创建出来的同时,其回呼函数的主体就会立刻被运行。
let future = async {
let inner_future = async {
println!("Hello, world.");
0
};
let output = inner_future.await;
// ...
};
一个 Future 对象只能够被运行一次,想要运行多次 Future 对象的内容,就要重复产生该 Future 对象。
我们也可以在 fn、unsafe fn 关键字前,加上 async 关键字,定义出来的函数就是 Future 对象的产生器;或者在闭包前或是闭包的 move 关键字前,加上 async 关键字,定义出来的闭包就是 Future 对象的产生器。
let future = async {
async fn generate_future() -> i32 {
println!("Hello, world.");
0
}
let inner_future = generate_future();
let output = inner_future.await;
// ...
};
至此您可能会发现这个「async / await」语法好像一点用也没有,因为每次调用 Future 对象都一样是阻塞的(blocking),到底哪里并发了?而且若是在开发应用程序,main 函数还不能够加上 async 关键字,根本就不能在 main 函数中运行 Future 对象嘛!
先别急,这是因为我们现在能看到的函数库(如标准函数库)完全都是阻塞的(blocking)才会有「async / await」语法一点用都没有的感觉,引用了其它异步 runtime 后,情况就会不一样了。
futures
futures 是一个开发异步程序时使用的基本函数库。它也提供了 block_on 函数,让我们可以在非 async 的程序区块(尤其是 main 函数)中运行 Future 对象。
[dependencies]
futures = "0.3"
use futures::executor::block_on;
fn main() {
let inner_future = async {
println!("Hello, world.");
0
};
let output = block_on(inner_future);
// ...
}
异步 runtime
异步 runtime 用来提供异步程序进入点和基础的异步 I/O 函数,以及任务运行器(executor)或者说 Future 运行器。目前的 Rust 生态圈有三种主要的异步 runtime,分别是 tokio、async-std 和 smol。
先看看以下这个程序:
use std::{
error::Error,
io::{Read, Write},
net::TcpListener,
thread,
};
fn main() -> Result<(), Box<dyn Error>> {
let listener = TcpListener::bind("127.0.0.1:8080")?;
loop {
let (mut socket, _) = listener.accept()?;
thread::spawn(move || {
let mut buf = [0; 1024];
loop {
let n = match socket.read(&mut buf) {
Ok(0) => return,
Ok(n) => n,
Err(e) => {
eprintln!("failed to read from socket; err = {e:?}");
return;
},
};
if let Err(e) = socket.write_all(&buf[0..n]) {
eprintln!("failed to write to socket; err = {e:?}");
return;
}
}
});
}
}
上面是一个 TCP 服务器的程序,接受一个连接之后就打开新的线程来处理,会将传入的数据原封不动地回传。
tokio
tokio 是最被广泛使用的 runtime,提供多种 API,可以激活 full 特色来全部激活。
以下是用 tokio 来实作上面那个 TCP 服务器程序的代码:
[dependencies]
tokio = { version = "1", features = ["full"] }
use std::error::Error;
use tokio::{
io::{AsyncReadExt, AsyncWriteExt},
net::TcpListener,
};
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
let listener = TcpListener::bind("127.0.0.1:8080").await?;
loop {
let (mut socket, _) = listener.accept().await?;
tokio::spawn(async move {
let mut buf = [0; 1024];
loop {
let n = match socket.read(&mut buf).await {
Ok(0) => return,
Ok(n) => n,
Err(e) => {
eprintln!("failed to read from socket; err = {e:?}");
return;
},
};
if let Err(e) = socket.write_all(&buf[0..n]).await {
eprintln!("failed to write to socket; err = {e:?}");
return;
}
}
});
}
}
以上是使用 tokio 实作的 TCP 服务器,看起来好像没有产生新线程,但实际上它在一开始就会产生一个线程池(Thread Pool),用来运行 tokio::spawn 传进去的 Future 对象。
线程池的线程数量预设是处理器(逻辑处理器)的数量,如果要更改的话,可以替 #[tokio::main] 属性加上 worker_threads 参数。如下,可以让线程池使用 4 个线程:
use std::error::Error;
use tokio::{
io::{AsyncReadExt, AsyncWriteExt},
net::TcpListener,
};
#[tokio::main(worker_threads = 4)]
async fn main() -> Result<(), Box<dyn Error>> {
let listener = TcpListener::bind("127.0.0.1:8080").await?;
loop {
let (mut socket, _) = listener.accept().await?;
tokio::spawn(async move {
let mut buf = [0; 1024];
loop {
let n = match socket.read(&mut buf).await {
Ok(0) => return,
Ok(n) => n,
Err(e) => {
eprintln!("failed to read from socket; err = {e:?}");
return;
},
};
if let Err(e) = socket.write_all(&buf[0..n]).await {
eprintln!("failed to write to socket; err = {e:?}");
return;
}
}
});
}
}
即便将 worker_threads 设置为 1,TCP 服务器也还是可以正常允许同时间有多笔连接,这就是异步 runtime 真正厉害的地方啦!
async-std
async-std 强调对应 Rust 的标准函数库,可以将其看作是 std 的异步版本。激活 attributes 特色可以使用 #[async_std::main] 属性来创建程序进入点,用法就如同 #[tokio::main]。
以下是用 async-std 来实作上面那个 TCP 服务器程序的代码:
[dependencies]
async-std = { version = "1", features = ["attributes"] }
use std::error::Error;
use async_std::{net::TcpListener, prelude::*, task};
#[async_std::main]
async fn main() -> Result<(), Box<dyn Error>> {
let listener = TcpListener::bind("127.0.0.1:8080").await?;
loop {
let (mut socket, _) = listener.accept().await?;
task::spawn(async move {
let mut buf = [0; 1024];
loop {
let n = match socket.read(&mut buf).await {
Ok(0) => return,
Ok(n) => n,
Err(e) => {
eprintln!("failed to read from socket; err = {e:?}");
return;
},
};
if let Err(e) = socket.write_all(&buf[0..n]).await {
eprintln!("failed to write to socket; err = {e:?}");
return;
}
}
});
}
}
以上是使用 async-std 实作的 TCP 服务器,看起来好像没有产生新线程,但实际上它在一开始就会产生一个线程池,用来运行 task::spawn 传进去的 Future 对象。
线程池的线程数量预设是处理器(逻辑处理器)的数量,如果要更改的话,直接透过环境变量 ASYNC_STD_THREAD_COUNT 来设置即可。同样地,即便将 ASYNC_STD_THREAD_COUNT 设为 1,TCP 服务器也还是可以正常允许同时间有多笔连接。
smol
smol 是轻巧又快速的异步 runtime,用法上与前面两者比较不同。
以下是用 smol 来实作上面那个 TCP 服务器程序的代码:
[dependencies]
smol = "1"
use std::error::Error;
use smol::{
io::{AsyncReadExt, AsyncWriteExt},
net::TcpListener,
};
fn main() -> Result<(), Box<dyn Error>> {
smol::block_on(async {
let listener = TcpListener::bind("127.0.0.1:8080").await?;
loop {
let (mut socket, _) = listener.accept().await?;
smol::spawn(async move {
let mut buf = [0; 1024];
loop {
let n = match socket.read(&mut buf).await {
Ok(0) => return,
Ok(n) => n,
Err(e) => {
eprintln!("failed to read from socket; err = {e:?}");
return;
},
};
if let Err(e) = socket.write_all(&buf[0..n]).await {
eprintln!("failed to write to socket; err = {e:?}");
return;
}
}
})
.detach();
}
})
}
以上是使用 smol 实作的 TCP 服务器,看起来好像没有产生新线程,但实际上它在一开始就会产生一个线程池,用来运行 smol::spawn 传进去的 Future 对象。
线程池的线程数量预设是 1,如果要更改的话,直接透过环境变量 SMOL_THREADS 来设置即可。同样地,即便没有设置 SMOL_THREADS,或是将 SMOL_THREADS 设为 1,TCP 服务器也还是可以正常允许同时间有多笔连接。
