用「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 服务器也还是可以正常允许同时间有多笔连接。