Rust专项——Tokio异步与async/await实战入门

红目香薰

发布于 2025-12-16 16:22:22

1840

文章被收录于专栏：CSDNToQQCodeCSDNToQQCode

本篇带你体验Rust异步世界，基于Tokio运行时，掌握async/await关键语法，高效IO与高并发的解决之道。

1. 为什么需要异步与Tokio？

传统多线程模型下，IO密集/高并发时可能导致线程爆炸与上下文切换性能损耗。
异步模型（基于future）下，少量线程协作驱动数万~百万IO任务，非常适合网络服务、网关、爬虫、消息队列等。
Tokio是最主流的Rust异步生态，生态完整，广泛应用于工业生产环境。

2. async/await 最基本用法

需要添加对应的tokio

[package]
name = "my_library"
version = "0.1.0"
edition = "2021"
[dependencies]
tokio = { version = "1", features = ["full"] }

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

#[tokio::main]
async fn main() {
    println!("begin");
    sleep(Duration::from_secs(1)).await;
    println!("end");
}

#[tokio::main] 宏会自动启动Tokio运行时，支持 .await 语法。
异步函数返回 impl Future，通过 .await 让出控制权。

3. 并发执行与任务调度

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

#[tokio::main]
async fn main() {
    let h1 = tokio::spawn(async { sleep(Duration::from_millis(700)).await; "A" });
    let h2 = tokio::spawn(async { sleep(Duration::from_millis(300)).await; "B" });
    let v = tokio::try_join!(h1, h2).unwrap();
    println!("Both joined result: {:?}", v);
}

tokio::spawn 用于派发任务到线程池。
tokio::join! / try_join! 并发等待多个future全部完成。

4. Tokio通道与共享状态

use tokio::sync::mpsc;

#[tokio::main]
async fn main() {
    let (tx, mut rx) = mpsc::channel(32);
    tokio::spawn(async move {
        for i in 0..5 {
            tx.send(format!("msg-{i}")).await.unwrap();
        }
    });
    while let Some(msg) = rx.recv().await {
        println!("got {msg}");
    }
}

Tokio自带多种并发原语： mpsc/rwlock/mutex/oneshot 等。
与标准库mpsc写法类似，但支持异步 .await。

5. 定时与延时任务

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

#[tokio::main]
async fn main() {
    let mut ticks = interval(Duration::from_secs(1));
    for _ in 0..5 {
        ticks.tick().await;
        println!("tick");
    }
}

6. 网络服务案例（最简单TCP echo服务器）

use tokio::net::TcpListener;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
    loop {
        let (mut socket, _) = listener.accept().await?;
        tokio::spawn(async move {
            let mut buf = [0u8; 1024];
            loop {
                let n = match socket.read(&mut buf).await {
                    Ok(0) => break,
                    Ok(n) => n,
                    Err(_) => break,
                };
                if socket.write_all(&buf[..n]).await.is_err() {
                    break;
                }
            }
        });
    }
}