1 Rust 异步

所谓异步（Async），是指在少量线程环境下运行多个独立任务。嵌入式中的的RTOS（Real Time OS，实时操作系统）就可以看作一种异步编程。异步编程适用于IO密集型任务。

所谓IO密集型任务，是指CPU在运行过程中需要多次和数据以及地址总线交互，并且任务的运行效率主要局限于输入输出端口的读写时间的任务，例如读写内存，读写大量文件，执行Web请求等。与之相比的是CPU密集型任务，它指的是程序的运行效率主要局限于CPU的运算效率，例如执行大量运算。

对于IO密集型任务，程序中的大量时间实际上都处于“等待”状态，所谓异步就是通过某种算法（任务调度器）使得CPU把这些“等待”的时间都利用起来的编程方式。一般来说，IO受限（IO Bound）的程序（程序执行的速度依赖于IO子系统的速度）比起CPU受限（CPU Bound）的任务（程序执行的速度依赖于CPU的运算速度）可能更适合于异步任务的执行（也不是绝对的，存在例外）。

Rust标准库本身并没有提供异步的运行时（环境），而是仅仅提供了用于异步编程的关键字async和.await（相当于提供了语法糖），他们是Rust标准库里用于异步编程的内置核心原语的代表。Rust的异步运行时由Rust社区提供和维护。

博主学习异步编程主要是为了为后续嵌入式编程打基础。实际上，如果你的项目没有必要应用异步技术，那么从功利的角度说，就不需要花费大量时间研究异步编程。

1. 各个线程之间的执行顺序无法预测；
2. 线程之间可能发生死锁；
3. 线程之间可能发生竞争；

tokio是适用于Rust的一个异步运行时（库），使用时需要在Cargo.toml文件中的dependencies模块中对其进行声明：

[dependencies]
tokio = {version = "1", features = ["full"]}

看下面这个例子：从两个文件中读取数据，第一个文件读取需要4s，第二个文件读取需要2s。使用异步的方式创建两个异步任务（函数），并且通过await关键字来使得异步任务得以执行：

use std::thread::sleep;
use std::time::Duration;

#[tokio::main]
async fn main() {
    println!("Hello before reading file!");

    let h1 = tokio::spawn(async {
        let _file1_contents = read_from_file1().await;      // 调用异步任务函数使用.await关键字
    });

    let h2 = tokio::spawn(async {
        let _file2_contents = read_from_file2().await;
    });

    let _ = tokio::join!(h1, h2);
}

async fn read_from_file1() -> String {      // 异步函数，惰性的，只有遇到.await关键字才会执行
    sleep(Duration::new(4, 0));
    println!("{:?}", "Processing file 1");
    String::from("Hello there from file 1")
}

async fn read_from_file2() -> String {      // 异步函数，惰性的，只有遇到.await关键字才会执行
    sleep(Duration::new(2, 0));
    println!("{:?}", "Processing file 2");
    String::from("Hello there from file 2")
}

use std::future::Future;

fn read_from_file1() -> impl Future<Output = String> {
    async {
        sleep(Duration::new(4, 0));
        println!("{:?}", "Processing file 1");
        String::from("Hello there from file 1")
    }
}

fn read_from_file2() -> impl Future<Output = String> {
    async {
        sleep(Duration::new(2, 0));
        println!("{:?}", "Processing file 2");
        String::from("Hello there from file 2")
    }
}

pub trait Future {
    /// The type of value produced on completion.
    #[stable(feature = "futures_api", since = "1.36.0")]
    #[lang = "future_output"]
    type Output;

    // some comments ...

    #[lang = "poll"]
    #[stable(feature = "futures_api", since = "1.36.0")]
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}

use std::future::Future;
use std::thread::sleep;
use std::time::Duration;

use std::pin::Pin;
use std::task::{Context, Poll};      // Context 包含异步任务的上下文，可以用来唤醒当前的任务

struct ReadFileFuture {}

impl Future for ReadFileFuture {
    type Output = String;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        println!("Tokio! Stop polling me!");
        Poll::Pending
    }
}

#[tokio::main]
async fn main() {
    println!("Hello before reading file!");

    let h1 = tokio::spawn(async {
        let future1 = ReadFileFuture {};
        future1.await
    });

    let h2 = tokio::spawn(async {
        let _file2_contents = read_from_file2().await;
    });

    let _ = tokio::join!(h1, h2);
}

//
async fn read_from_file2() -> String {
    sleep(Duration::new(2, 0));
    println!("{:?}", "Processing file 2");
    String::from("Hello there from file 2")
}

use std::future::Future;
use std::thread::sleep;
use std::time::{Duration, Instant};

use std::pin::Pin;
use std::task::{Context, Poll};

struct AsyncTimer {
    expiration_time: Instant,
}

impl Future for AsyncTimer {
    type Output = String;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        if Instant::now() >= self.expiration_time {
            println!("Time is over!");
            Poll::Ready(String::from("Future 1 is completed"))
        } else {
            println!("It's not yet time 1 for Future 1. Going to sleep");
            let waker = cx.waker().clone();
            let expiration_time = self.expiration_time;

            std::thread::spawn(move || {
                let current_time = Instant::now();

                if current_time < expiration_time {
                    sleep(expiration_time - current_time);
                }
                waker.wake();
            });
            Poll::Pending
        }
    }
}

#[tokio::main]
async fn main() {
    let h1 = tokio::spawn(async {
        let future1 = AsyncTimer {
            expiration_time: Instant::now() + Duration::from_millis(4000),
        };
        println!("{:?}", future1.await);
    });

    let h2 = tokio::spawn(async {
        let file2_content = read_from_file2().await;
        println!("{}", file2_content);
    });

    let _ = tokio::join!(h1, h2);
}

async fn read_from_file2() -> String {
    sleep(Duration::new(2, 0));
    String::from("Future 2 has completed!")
}

上面的例子中，AsyncTimer的poll方法只会被调用两次。