Rust异步编程之异步运行时（rust 异步网络）

为什么需要运行时？

异步任务的执行机制

在Rust中，异步任务通常表示为 Future，但这些任务并不能自己执行。它们需要一个 运行时（Runtime）来调度和执行异步操作。

• 异步任务本质上是通过调用 poll 方法来检查是否完成。
• 如果任务尚未完成，运行时将其挂起，直到能够继续执行。
• 每当任务从挂起状态转为准备好执行时，运行时会触发 Waker 来通知任务继续运行。

Rust的异步任务机制并不依赖线程池的创建，而是通过 事件驱动 来调度任务。异步任务通过轮询机制执行，调用 poll 方法时会返回任务的状态（Pending 或 Ready）。

非阻塞IO的实现

非阻塞IO是实现高效并发的核心，异步编程能够避免传统同步编程中阻塞操作的瓶颈。

在传统的同步程序中，如果程序执行了一个IO操作（如网络请求或文件读取），线程会被阻塞，直到操作完成。与此不同，异步编程允许程序在等待IO操作完成的同时去执行其他任务。

运行时通过将所有IO操作的执行交给操作系统的事件通知机制（如 epoll、kqueue）来避免线程阻塞。这样，多个IO操作可以在同一线程中并发处理，而无需额外的上下文切换。

主流运行时介绍

Tokio

Tokio 是Rust生态中最流行的异步运行时。它不仅提供了异步任务的调度，还包括异步IO、定时器、网络服务等一整套功能。

特性：

• 强大的多线程支持，适合高并发的应用场景。
• 丰富的生态支持，包括数据库连接池（tokio-postgres）、HTTP客户端（reqwest）、异步文件操作等。
• 高度优化的任务调度机制，提供对任务的细粒度控制。

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

代码示例:

use tokio::time::{sleep, Duration};

async fn do_work() {
    println!("Hello, world!");
    sleep(Duration::from_secs(1)).await;
    println!("Bye bye!");
}

#[tokio::main]
async fn main() {
    do_work().await;
}

async-std

async-std 是一个轻量级的异步运行时，旨在提供类似于Rust标准库的API，便于开发者更容易上手异步编程。

特性：

• 提供与标准库接口兼容的异步功能，如文件、网络IO等。
• 适用于不需要复杂调度和高并发的应用。
• 较小的体积，适合小型项目或低资源环境。

[dependencies]
async-std = "1.13.0"

代码示例:

use std::time::Duration;
use async_std::task;
use async_std::task::sleep;

async fn do_work() {
    println!("Hello, world!");
    async_std::task::sleep(Duration::from_secs(1)).await;
    println!("Bye bye!");
}

fn main() {
    task::block_on(do_work());
}

smol

smol 是一个轻量级的异步运行时，设计目标是简单、快速，适用于嵌入式或对性能要求非常高的应用。

特性：

• 极简的API，易于嵌入和集成。
• 小巧的体积，几乎没有依赖，适合微服务、单元测试等场景。
• 对大多数基本需求提供支持，如任务调度和非阻塞IO。

[dependencies]
smol = "2.0.2"

代码示例:

use std::time::Duration;
use smol::Timer;

async fn do_work() {
    println!("Hello, world!");
    Timer::after(Duration::from_secs(1)).await;
    println!("Bye bye!");
}

fn main() {
    smol::block_on(do_work());
}

对比与选择

• Tokio：适合高并发、性能要求高的应用，提供广泛的功能支持，但可能有较大的依赖和学习曲线。
• async-std：适合快速开发、资源较少的应用，API设计与标准库兼容，学习曲线较低。
• smol：适合嵌入式或要求极简的场景，体积小且快速，适用于低资源应用。

创建和运行异步任务

单线程 vs 多线程运行时

• 单线程运行时：在单线程上调度所有的异步任务。只有一个线程来执行所有任务，因此线程间的上下文切换非常低，适合任务较轻、IO密集型的应用。
• 多线程运行时：多个线程并行执行异步任务。每个线程都能并行执行多个任务，适合CPU密集型任务或高并发需求的应用。
• Tokio的默认运行时支持多线程，tokio::main 默认使用多线程模式。
• async-std和smol通常使用单线程模式，但也可以通过配置使用多线程。

代码示例（Tokio 多线程模式）：

#[tokio::main]
async fn main() {
    let handler1 = tokio::spawn(async { println!("handler1") });
    let handler2 = tokio::spawn(async { println!("handler2") });

    handler1.await.unwrap();
    handler2.await.unwrap();
}

tokio::spawn 和 async-std::task::spawn

• 在Tokio和async-std中，spawn 用于启动一个异步任务。
• tokio::spawn：适用于Tokio运行时，返回一个 JoinHandle，用于等待任务的完成。

代码示例（Tokio）：

async fn hello() {
    println!("hello");
}

#[tokio::main]
async fn main() {
   let task = tokio::spawn(hello());
    task.await.unwrap();
}

• async-std::task::spawn：适用于async-std运行时，也用于启动异步任务。

代码示例（async-std）：

async fn hello() {
    println!("hello");
}

fn main() {
    async_std::task::block_on(async {
        async_std::task::spawn(hello()).await;
    });
}

总结

1.运行时的必要性：Rust的异步任务需要运行时来调度和管理任务的执行，确保任务按顺序执行并不会阻塞线程。运行时通过非阻塞IO和事件驱动机制高效管理异步任务。

2.主流异步运行时：

• Tokio：功能强大，适用于高并发、高性能应用。
• async-std：轻量级，适用于小型项目或低资源场景。
• smol：极简设计，适用于嵌入式和性能要求较高的应用。

3.选择运行时：根据应用场景的并发需求、性能要求和生态支持选择合适的运行时。

4.创建和运行异步任务：通过 tokio::spawn 或 async-std::task::spawn 启动异步任务，选择单线程或多线程运行时，能更灵活地处理任务调度与资源使用。

今天的内容到此就结束了，感谢收看，如果本文对你有所收获，欢迎关注，点赞，收藏和转发，我会坚持分享相关的rust内容！！！