Tokio：Rust 异步运行时核心指南

Tokio：Rust 异步运行时核心指南 | 极客日志

特性	说明	为什么重要
高性能	基于事件驱动和非阻塞 I/O。	能够以极低的延迟处理数万甚至数十万的并发连接，非常适合构建微服务和代理服务器。
可靠	基于 Rust 的内存安全保证。	避免了传统 C/C++ 网络库常见的内存泄漏、空指针等崩溃问题，系统更加稳定。
易用	完美支持 `async/await` 语法。	让异步代码看起来像同步代码一样直观，降低了心智负担。
灵活	提供单线程和多线程运行时选项。	你可以根据场景选择：是追求极致的单核性能（单线程），还是充分利用多核（多线程）。

[dependencies]
tokio = { version = "1.0", features = ["rt-multi-thread", "macros"] }
# rt-multi-thread：多线程运行时（推荐生产环境）
# macros：提供#[tokio::main]、#[tokio::test]等宏

[dependencies]
tokio = {
    version = "1.0",
    features = [
        "rt-multi-thread", # 多线程运行时
        "macros",          # 宏支持
        "fs",              # 异步文件 IO
        "net",             # 网络编程（TCP/UDP）
        "sync",            # 异步同步原语（Mutex、Semaphore 等）
        "time",            # 异步时间管理（定时任务）
        "signal"           # 信号处理（如中断信号）
    ]
}

// 基础用法：#[tokio::main] 宏启动多线程运行时
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Tokio 多线程运行时启动成功");
    // 异步任务逻辑...
    Ok(())
}

// 进阶：手动构建运行时（自定义线程数）
fn main() {
    // 配置运行时：核心线程数=4，最大线程数=8
    let rt = tokio::runtime::Builder::new_multi_thread()
        .worker_threads(4)
        .max_blocking_threads(8)
        .enable_all()
        .build()
        .unwrap();

    // 在运行时中执行异步任务
    rt.block_on(async {
        println!("手动构建的运行时执行异步任务");
    });
}

#[tokio::main(worker_threads = 4)]
async fn main() {
    println!("Hello world!");
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
    println!("使用单线程运行时");
}

方式	执行方式	适用场景
直接 `await`	顺序执行（排队）	任务有依赖、简单任务、必须等结果
`tokio::spawn`	并发执行（并排跑）	多个独立耗时任务、后台任务、提高效率

#[tokio::main]
async fn main() {
    // 1. 创建异步任务（无返回值）
    let task1 = async {
        println!("任务 1 开始执行");
        tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
        println!("任务 1 执行完成");
    };

    // 2. 创建带返回值的异步任务
    let task2 = async {
        println!("任务 2 开始执行");
        tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
        println!("任务 2 执行完成");
        42 // 返回值：i32
    };

    // 等待任务 1 完成（忽略返回值）
    let _ = task1.await;
    println!("任务 1 无返回值");

    // 等待任务 2 完成并获取返回值
    let result = task2.await;
    println!("任务 2 返回值：{}", result);
}

#[tokio::main]
async fn main() {
    // 1. 创建异步任务（无返回值）
    let task1 = tokio::spawn(async {
        println!("任务 1 开始执行");
        tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
        println!("任务 1 执行完成");
    });

    // 2. 创建带返回值的异步任务
    let task2 = tokio::spawn(async {
        println!("任务 2 开始执行");
        tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
        println!("任务 2 执行完成");
        42 // 返回值：i32
    });

    // 等待任务 1 完成（忽略返回值）
    let _ = task1.await;
    println!("任务 1 无返回值");

    // 等待任务 2 完成并获取返回值
    let result = task2.await.unwrap();
    println!("任务 2 返回值：{}", result);
}

let handle = tokio::spawn(async { 1 + 2 });
let result = handle.await.unwrap(); // 等待任务完成，获取结果：3
println!("任务结果：{}", result);

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

async fn fetch_user(user_id: u32) -> String {
    println!("fetch_user start");
    sleep(Duration::from_millis(500)).await;
    println!("fetch_user end");
    format!("User {}", user_id)
}

async fn fetch_orders(user_id: u32) -> Vec<String> {
    println!("fetch_orders start");
    sleep(Duration::from_millis(150)).await;
    println!("fetch_orders end");
    vec![format!("Order 1 for user {}", user_id)]
}

#[tokio::main]
async fn main() {
    let user_id = 42;
    // 并发执行两个任务，总耗时约等于耗时最长的那个（150ms）
    let (user, orders) = tokio::join!(fetch_user(user_id), fetch_orders(user_id));
    println!("User: {}", user);
    println!("Orders: {:?}", orders);
}

use tokio::task::JoinSet;
use std::time::Duration;

async fn process_item(id: u32) -> String {
    // 模拟一些异步工作
    tokio::time::sleep(Duration::from_millis(100)).await;
    format!("处理完成：{}", id)
}

#[tokio::main]
async fn main() {
    let mut join_set = JoinSet::new();

    // 1. 动态添加 5 个任务
    for i in 0..5 {
        join_set.spawn(async move {
            process_item(i).await;
        });
    }

    // 2. 等待所有任务完成并收集结果
    // join_all 会返回一个 Vec，包含每个任务的结果
    let results = join_set.join_all().await;

    // 3. 处理结果
    for result in results {
        println!("{}", result);
    }
}

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

async fn fetch_user(user_id: u32) -> String {
    println!("fetch_user start");
    sleep(Duration::from_millis(500)).await;
    println!("fetch_user end");
    format!("User {}", user_id)
}

async fn fetch_orders(user_id: u32) -> Vec<String> {
    println!("fetch_orders start");
    sleep(Duration::from_millis(150)).await;
    println!("fetch_orders end");
    vec![format!("Order 1 for user {}", user_id)]
}

#[tokio::main]
async fn main() {
    let user_id = 42;
    tokio::select! {
        user = fetch_user(user_id) => println!("User: {}", user),
        orders = fetch_orders(user_id) => println!("Orders: {:?}", orders),
    }
    println!("main end");
}

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

async fn fetch_data() -> Result<String, &'static str> {
    // 模拟一个可能耗时过长的操作
    sleep(Duration::from_secs(10)).await;
    Ok("Hello, World!".to_string())
}

#[tokio::main]
async fn main() {
    tokio::select! {
        // 分支 1：尝试获取数据
        result = fetch_data() => {
            match result {
                Ok(data) => println!("成功获取数据：{}", data),
                Err(e) => println!("获取数据失败：{}", e),
            }
        }
        // 分支 2：一个 2 秒的超时定时器
        _ = sleep(Duration::from_secs(2)) => {
            println!("获取数据超时！");
        }
    }
}

特性	`tokio::spawn`	`tokio::task::spawn_blocking`
任务类型	异步任务 (Async) 编写为 `async` 块或函数，内部使用 `.await` 进行非阻塞等待。	同步任务 (Sync/Blocking) 编写为普通的同步闭包或函数，可能会执行 `std::thread::sleep`、复杂的 CPU 计算等阻塞操作。
执行位置	主工作线程池 (Worker Pool) 任务由 Tokio 的调度器在少量的工作线程上快速切换执行。	专用阻塞线程池 (Blocking Pool) 任务被移动到一个独立的、专门为阻塞操作准备的线程池中执行。
适用场景	I/O 密集型任务如：网络请求、文件读写、数据库查询等。	CPU 密集型或同步阻塞任务如：复杂计算、数据压缩、调用不支持异步的库、`std::fs` 文件操作等。
对运行时的影响	协作式调度任务会在 `.await` 点主动让出，保证其他任务公平执行。	隔离保护阻塞任务被'移走'，防止它霸占主工作线程，导致其他异步任务'饿死'。
返回值	`JoinHandle<T>` 一个 Future，`.await` 后可获取异步任务的结果。	`JoinHandle<T>` 同样是一个 Future，可以 `.await` 等待同步任务完成并获取结果。

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

// 1. 定义一个耗时的同步计算函数 (这会阻塞线程)
// 注意：这不是 async 函数，它会一直占用 CPU 直到算完
fn cpu_intensive_task(n: u32) -> u64 {
    println!("开始执行耗时的 CPU 计算 (斐波那契 {})...", n);
    // 模拟复杂的计算过程 (简单的循环版斐波那契)
    let (mut a, mut b) = (0, 1);
    for _ in 0..n {
        let temp = a + b;
        a = b;
        b = temp;
    }
    // ⚠️ 危险操作：在 async 函数中执行同步的 sleep
    // 这会强制当前线程休眠 5 秒，期间无法做任何其他事
    std::thread::sleep(Duration::from_millis(2000));
    println!("CPU 计算完成!");
    b
}

#[tokio::main]
async fn main() {
    // --- 场景 A: 启动一个正常的异步任务 ---
    // 这个任务负责每 500ms 打印一次，用来检测主线程是否卡顿
    let monitor_handle = tokio::spawn(async move {
        let mut interval = time::interval(Duration::from_millis(500));
        for i in 0..10 {
            interval.tick().await; // .await 让出控制权，不会卡住线程
            println!("> {i} 监控任务：系统运行正常");
        }
    });

    // --- 场景 B: 执行耗时的 CPU 计算 ---
    // 我们需要把阻塞任务放在 spawn_blocking 里
    // 这样它会被扔到专门的 "阻塞线程池" 里去跑，不会影响上面的 monitor_handle
    let compute_handle = tokio::task::spawn_blocking(|| {
        // 调用我们的同步函数
        cpu_intensive_task(20) // 假设算第 40 个斐波那契数需要一点时间
    });

    // 等待两个任务都完成
    // 注意：monitor 是非阻塞的，compute 是阻塞的，但被隔离了
    let _ = monitor_handle.await;
    let result = compute_handle.await.unwrap(); // 获取计算结果
    println!("最终结果：{}", result);
}

use tokio::sync::Semaphore;
use std::sync::Arc;
use tokio::time::{self, Duration, Instant};

async fn download_file(file_id: u32, duration: u64, semaphore: Arc<Semaphore>) {
    // 1. 先获取许可（在这里排队，直到有空位）
    let _permit = semaphore.acquire().await.unwrap();

    // 2. 获取许可后，再打印日志
    // 此时该任务已经稳稳地占住了一个坑位
    let current_active = 3 - semaphore.available_permits(); // 3 是最大数
    let start = Instant::now();
    println!("📥 [任务 {}] 开始工作 (耗时{}s)，当前并发数：{}/3", file_id, duration, current_active);

    // 3. 模拟耗时工作
    time::sleep(Duration::from_secs(duration)).await;
    println!("🚀 [任务 {}] 完成 (耗时{:.1}s)", file_id, start.elapsed().as_secs_f32());
}

#[tokio::main]
async fn main() {
    let semaphore = Arc::new(Semaphore::new(3));
    let durations = vec![2, 1, 3, 1, 2, 1, 4, 1, 2, 1];
    println!("🚀 开始下载，最大并发数：3\n");
    let mut join_set = tokio::task::JoinSet::new();
    for (i, duration) in durations.into_iter().enumerate() {
        let sem = semaphore.clone();
        join_set.spawn(async move {
            download_file(i as u32, duration, sem).await;
        });
    }
    while let Some(_) = join_set.join_next().await {
        // 等待全部完成
    }
    println!("\n🎉 全部完成！");
}

use tokio::sync::mpsc;
use std::time::Duration;

// 定义消息类型，可以是枚举，包含不同种类的信息
#[derive(Debug)]
enum Message {
    Log {
        level: String,
        content: String,
    },
    Shutdown, // 用于通知消费者关闭
}

#[tokio::main]
async fn main() {
    // 1. 创建一个有界通道
    // 这里的 32 是缓冲区大小，如果发送太快，接收方没消费，缓冲区满了发送就会等待
    let (tx, mut rx) = mpsc::channel(32);

    // --- 启动消费者任务 (负责接收和处理) ---
    // 注意：这里我们把接收端 rx 移动到了任务里
    let handle = tokio::spawn(async move {
        // 消费者逻辑
        loop {
            match rx.recv().await {
                Some(Message::Log { level, content }) => {
                    println!("[消费者] 收到日志 [{}] : {}", level, content);
                    // 模拟处理耗时
                    tokio::time::sleep(Duration::from_millis(100)).await;
                }
                Some(Message::Shutdown) => {
                    println!("[消费者] 收到关闭指令，正在退出...");
                    break;
                }
                None => {
                    // 所有的发送端 (tx) 都被丢弃了，通道关闭
                    println!("[消费者] 所有发送端已关闭，退出循环。");
                    break;
                }
            }
        }
    });

    // --- 模拟多个生产者任务 (负责发送) ---
    // 我们克隆发送端，给每个任务一个副本
    let tx1 = tx.clone();
    let producer1 = tokio::spawn(async move {
        for i in 1..=3 {
            // 发送日志
            let _ = tx1.send(Message::Log {
                level: "INFO".to_string(),
                content: format!("生产者 1 的任务 {}", i),
            }).await;
            tokio::time::sleep(Duration::from_millis(50)).await;
        }
    });

    let producer2 = tokio::spawn(async move {
        for i in 1..=3 {
            let _ = tx.send(Message::Log {
                level: "ERROR".to_string(),
                content: format!("生产者 2 发现错误 {}", i),
            }).await;
            tokio::time::sleep(Duration::from_millis(70)).await;
        }
    });

    // 等待生产者完成
    let _ = tokio::join!(producer1, producer2);

    // 等待消费者完成
    let _ = handle.await;
    println!("所有任务结束，程序退出。");
}

use std::sync::Arc;
use tokio::sync::Mutex;

#[tokio::main]
async fn main() {
    // 1. 创建一个被 Arc 包裹的 Mutex
    // Arc 用于多所有权，Mutex 用于异步互斥访问
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    // 2. 派生 10 个任务
    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = tokio::spawn(async move {
            // 3. 锁定 Mutex (异步等待)
            // 这里会返回一个 Guard，只要 Guard 存在，锁就持有
            let mut num = counter.lock().await;
            *num += 1;
            // 锁在 num 离开作用域时自动释放
        });
        handles.push(handle);
    }

    // 等待所有任务完成
    for handle in handles {
        handle.await.unwrap();
    }

    // 检查最终结果
    println!("最终计数：{}", *counter.lock().await); // 应该输出 10
}

use std::sync::Mutex;
use tokio::task;

#[tokio::main]
async fn main() {
    let std_mutex = Arc::new(Mutex::new(0));
    let handle = task::spawn_blocking({
        let std_mutex = Arc::clone(&std_mutex);
        move || {
            // 在这里使用 std::sync::Mutex 是安全的
            let mut data = std_mutex.lock().unwrap();
            *data += 1;
        }
    });
    handle.await.unwrap();
}

use std::sync::Arc;
use tokio::sync::Mutex; // 引入 Tokio 的异步互斥锁
use std::time::Duration;

#[tokio::main]
async fn main() {
    // 1. 创建共享状态
    // 使用 Arc (原子引用计数) 来跨任务共享所有权
    // 使用 Mutex 来保证同一时间只有一个任务能修改数据
    let counter = Arc::new(Mutex::new(0));

    // 存储任务句柄的向量
    let mut handles = vec![];

    // 2. 派生 10 个并发任务
    for i in 0..10 {
        let counter = Arc::clone(&counter); // 克隆 Arc，增加引用计数
        // 每个任务都在后台运行
        let handle = tokio::spawn(async move {
            // 模拟一些异步工作（比如网络请求）
            // 注意：这里不能使用 std::thread::sleep，那会阻塞线程
            tokio::time::sleep(Duration::from_millis(100)).await;

            // 3. 获取锁并修改数据
            // lock() 是异步的，如果锁被占用，任务会自动让出控制权给其他任务
            let mut num = counter.lock().await;
            *num += 1;
            println!("任务 {} 完成，当前计数：{}", i, *num);
        });
        handles.push(handle);
    }

    // 4. 等待所有任务完成
    for handle in handles {
        handle.await.unwrap();
    }

    // 5. 检查最终结果
    println!("所有任务结束，最终计数：{}", *counter.lock().await);
}

use tokio::task::LocalKey; // 引入线程本地存储
use std::cell::RefCell; // 用于在单线程内实现内部可变性
use std::rc::Rc; // 用于单线程内的引用计数

// 1. 定义一个线程本地变量
// 这个变量的值在每个 Tokio 线程中都是独立的
thread_local! {
    static MY_THREAD_LOCAL: RefCell<Rc<String>> = RefCell::new(Rc::new("Default Value".to_string()));
}

#[tokio::main(flavor = "multi_thread", worker_threads = 2)]
async fn main() {
    // 指定使用多线程运行时，并启动 2 个 worker 线程

    // 2. 派生两个任务
    // 由于是多线程运行时，这两个任务很可能被调度到不同的 OS 线程上
    let handle1 = tokio::spawn(async {
        // 在任务 1 中修改线程本地变量
        MY_THREAD_LOCAL.with(|f| {
            // 获取当前线程的副本并修改
            *f.borrow_mut() = Rc::new("Value from Task 1".to_string());
        });

        // 读取并打印
        MY_THREAD_LOCAL.with(|f| {
            println!("Task 1 sees: {}", f.borrow());
        });
    });

    let handle2 = tokio::spawn(async {
        // 模拟一点延迟，增加调度到不同线程的概率
        tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;

        // 读取
        MY_THREAD_LOCAL.with(|f| {
            println!("Task 2 sees: {}", f.borrow());
        });
    });

    // 3. 等待任务完成
    handle1.await.unwrap();
    handle2.await.unwrap();

    // 4. 在主线程中读取
    // 主线程也有自己的线程本地变量副本
    MY_THREAD_LOCAL.with(|f| {
        println!("Main thread sees: {}", f.borrow());
    });
}

use tokio::fs;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. 读取文件内容
    let content = fs::read_to_string("test.txt").await?;
    println!("文件内容：\n{}", content);

    // 2. 写入文件（覆盖写入）
    let data = "Tokio 异步文件 IO 示例";
    fs::write("output.txt", data).await?;
    println!("文件写入完成");

    // 3. 创建目录并遍历
    fs::create_dir_all("demo_dir/sub_dir").await?;
    let entries = fs::read_dir("demo_dir").await?;
    for entry in entries {
        let entry = entry?;
        println!("目录项：{}", entry.path().display());
    }
    Ok(())
}

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

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 绑定地址并监听
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
    println!("TCP 服务器启动，监听 127.0.0.1:8080");

    // 循环接收客户端连接（异步阻塞，不占用线程）
    loop {
        let (stream, addr) = listener.accept().await?;
        println!("新客户端连接：{}", addr);

        // 为每个客户端创建独立任务处理（避免阻塞其他连接）
        tokio::spawn(handle_client(stream));
    }
}

// 处理单个客户端连接
async fn handle_client(mut stream: TcpStream) -> Result<(), Box<dyn std::error::Error>> {
    let mut buf = [0; 1024]; // 缓冲区

    // 读取客户端数据
    let n = stream.read(&mut buf).await?;
    if n == 0 {
        return Ok(()); // 客户端关闭连接
    }
    println!("收到客户端数据：{}", String::from_utf8_lossy(&buf[..n]));

    // 向客户端发送响应
    let response = "已收到你的消息（来自 Tokio TCP 服务器）";
    stream.write_all(response.as_bytes()).await?;
    stream.flush().await?;
    Ok(())
}

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

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 连接服务器
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
    println!("已连接到 TCP 服务器");

    // 发送数据到服务器
    let data = "Hello, Tokio TCP Server!";
    stream.write_all(data.as_bytes()).await?;
    stream.flush().await?;

    // 读取服务器响应
    let mut buf = [0; 1024];
    let n = stream.read(&mut buf).await?;
    println!("收到服务器响应：{}", String::from_utf8_lossy(&buf[..n]));
    Ok(())
}

use tokio::sync::{Mutex, Semaphore};
use std::sync::Arc;

#[tokio::main]
async fn main() {
    // 场景 1：异步 Mutex（多任务安全访问共享数据）
    let counter = Arc::new(Mutex::new(0));
    let mut tasks = Vec::new();
    for i in 0..5 {
        let counter = Arc::clone(&counter);
        let task = tokio::spawn(async move {
            let mut num = counter.lock().await; // 异步锁定，不阻塞线程
            *num += 1;
            println!("任务{}：计数器值 = {}", i, *num);
        });
        tasks.push(task);
    }
    tokio::join!(tasks.iter().map(|t| t.clone()).collect::<Vec<_>>()[0].await); // 简化示意
    println!("最终计数器值：{}", *counter.lock().await);

    // 场景 2：Semaphore（控制并发数）
    let semaphore = Arc::new(Semaphore::new(2)); // 允许最大并发数=2
    let mut tasks = Vec::new();
    for i in 0..5 {
        let semaphore = Arc::clone(&semaphore);
        let task = tokio::spawn(async move {
            let permit = semaphore.acquire().await.unwrap(); // 获取许可
            println!("任务{}：开始执行（并发数控制）", i);
            tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
            drop(permit); // 释放许可
        });
        tasks.push(task);
    }
    tokio::join!(tasks.iter().map(|t| t.clone()).collect::<Vec<_>>()[0].await); // 简化示意
}

use tokio::time;

#[tokio::main]
async fn main() {
    // 场景 1：延迟执行（1 秒后执行任务）
    println!("延迟任务开始等待...");
    time::sleep(time::Duration::from_secs(1)).await;
    println!("延迟任务执行完成");

    // 场景 2：周期任务（每隔 2 秒执行一次，执行 3 次后退出）
    let mut interval = time::interval(time::Duration::from_secs(2));
    let mut count = 0;
    loop {
        interval.tick().await; // 等待周期触发
        count += 1;
        println!("周期任务执行，次数：{}", count);
        if count >= 3 {
            break;
        }
    }

    // 场景 3：截止时间（任务必须在指定时间内完成）
    let deadline = time::Instant::now() + time::Duration::from_secs(3);
    let result = time::timeout_at(deadline, async {
        time::sleep(time::Duration::from_secs(2)).await;
        "任务在截止时间前完成"
    }).await;
    match result {
        Ok(msg) => println!("{}", msg),
        Err(_) => println!("任务超时未完成"),
    }
}

use tokio;
use reqwest::Client;
use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct IpInfo {
    ip: String,
    country: String,
    city: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 创建可复用的 reqwest 客户端（基于 Tokio 异步运行时）
    let client = Client::new();

    // 并发发起多个 HTTP 请求
    let urls = vec![
        "https://ipapi.co/8.8.8.8/json/",
        "https://ipapi.co/1.1.1.1/json/",
        "https://ipapi.co/223.5.5.5/json/",
    ];
    let tasks = urls.into_iter().map(|url| async move {
        client.get(url).send().await?.json::<IpInfo>().await
    });
    let results = tokio::join!(tasks.collect::<Vec<_>>()[0].await); // 简化示意
    for (idx, result) in results.into_iter().enumerate() {
        match result {
            Ok(info) => println!("IP {} 信息：{:?}", idx + 1, info),
            Err(e) => eprintln!("IP {} 请求失败：{}", idx + 1, e),
        }
    }
    Ok(())
}

use tokio;
use tokio::signal;
use log::{info, warn};
use env_logger::Builder;
use chrono::Local;

#[tokio::main]
async fn main() {
    // 配置异步日志（结合 chrono 格式化时间戳）
    Builder::new()
        .format(|buf, record| {
            let time = Local::now().format("%Y-%m-%d %H:%M:%S.%f").to_string();
            writeln!(buf, "[{}] [{}] {}", time, record.level(), record.args())
        })
        .filter(None, log::LevelFilter::Info)
        .init();

    info!("服务启动成功，等待中断信号...");

    // 监听系统中断信号（Ctrl+C）
    let mut sigint = signal::unix::signal(signal::unix::SignalKind::interrupt())?;
    let mut sigterm = signal::unix::signal(signal::unix::SignalKind::terminate())?;

    // 等待任一中断信号
    tokio::select! {
        _ = sigint.recv() => warn!("收到 SIGINT 信号，准备退出"),
        _ = sigterm.recv() => warn!("收到 SIGTERM 信号，准备退出"),
    }
    info!("服务已优雅退出");
}

Tokio：Rust 异步运行时核心指南

概述

名气与地位：Rust 异步界的'霸主'

核心作用：它解决了什么问题？

具体功能与特点

一个简单的类比

避坑指南：它不擅长什么

总结

一、环境准备：引入 Tokio 与特性配置

1. 基础依赖（核心运行时 + 宏）

2. 常用拓展特性

二、核心基础：异步运行时与任务管理

1. 启动异步运行时

2. #[tokio::main] 的相关设置

3. spawn

3. spawn 的返回值

是什么

JoinHandle 的主要作用

任务取消（Drop 时自动取消）

4. 任务编排：join!

5. 任务编排：JoinSet（作用上同 join_all）

6. 任务编排：select!

7. spawn_blocking

8. Semaphore

9. 异步 channel：mpsc

10. 异步 Mutex

🧵 核心原理：线程 vs 协程

🚫 为什么在 Tokio 里用 std::sync::Mutex 是灾难？

✅ 什么时候可以用 std::sync::Mutex？

11. LocalKey

三、核心能力：异步 IO 与网络编程

1. 异步文件 IO

2. TCP 网络编程（客户端 + 服务器）

示例 1：异步 TCP 服务器

示例 2：异步 TCP 客户端

四、进阶特性：异步同步原语与定时任务

1. 异步同步原语

2. 定时任务与延迟执行

五、实战联动：Tokio 与生态库配合

1. 异步 HTTP 客户端（Tokio + reqwest）

2. 异步日志与信号处理（生产环境必备）

六、最佳实践与常见问题

1. 最佳实践

2. 常见问题

七、总结

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具

🚫 为什么在 Tokio 里用 `std::sync::Mutex` 是灾难？

✅ 什么时候可以用 `std::sync::Mutex`？