Rust异步运行时:从Tokio到生产环境实践

Rust:性能优异的异步并发库 Tokio Tokio是一个开源的异步运行时库,专为编写异步IO应用而设计。它提供了一种简单而安全的方式来编写异步代码,允许开发者无缝切换不同类型的异步运行时,并提供了统一的接口用于实现不同的功能,如网络IO、文件IO、数据库访问、HTTP客户端、多线程调度等。Tokio基于Rust语言开发,Rust是一种赋予每个人建立可靠和高效的软件的语言。Tokio的目标是通过提供一种简洁而强大的抽象层,使得异步编程更加容易和直观。它专注于提供一致的行为和可靠的响应时间,以构建可信的软件。 阅读详情

Rust异步运行时:从Tokio到生产环境实践

引言

异步编程是现代高性能后端服务的关键技术。Rust通过async/await语法和强大的运行时实现,提供了卓越的异步性能。

本文将深入探讨Rust的异步运行时,包括Tokio、async-std等运行时的原理、使用方法和最佳实践。

一、异步基础

1.1 async/await语法

use tokio;

async fn fetch_data(url: &str) -> Result<String, reqwest::Error> {
    let body = reqwest::get(url).await?.text().await?;
    Ok(body)
}

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let data = fetch_data("https://api.example.com").await?;
    println!("Data: {}", data);
    Ok(())
}

1.2 Future概念

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

struct MyFuture {
    count: u32,
}

impl Future for MyFuture {
    type Output = u32;
    
    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
        let this = self.get_mut();
        
        if this.count < 3 {
            this.count += 1;
            println!("Polling: {}", this.count);
            Poll::Pending
        } else {
            Poll::Ready(this.count)
        }
    }
}

#[tokio::main]
async fn main() {
    let result = MyFuture { count: 0 }.await;
    println!("Result: {}", result);
}

二、Tokio运行时

2.1 基本配置

use tokio;

#[tokio::main(flavor = "current_thread")]
async fn main() {
    println!("Single-threaded runtime");
}

// 多线程运行时
#[tokio::main(flavor = "multi_thread", worker_threads = 4)]
async fn main_multi() {
    println!("Multi-threaded runtime with 4 workers");
}

2.2 创建任务

use tokio;

async fn task_one() {
    println!("Task one started");
    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    println!("Task one completed");
}

async fn task_two() {
    println!("Task two started");
    tokio::time::sleep(std::time::Duration::from_secs(2)).await;
    println!("Task two completed");
}

#[tokio::main]
async fn main() {
    // 并发执行任务
    let handle1 = tokio::spawn(task_one());
    let handle2 = tokio::spawn(task_two());
    
    // 等待所有任务完成
    handle1.await.unwrap();
    handle2.await.unwrap();
}

2.3 资源管理

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

struct SharedCounter {
    value: Mutex<i32>,
}

impl SharedCounter {
    async fn increment(&self) {
        let mut val = self.value.lock().await;
        *val += 1;
    }
    
    async fn get(&self) -> i32 {
        *self.value.lock().await
    }
}

#[tokio::main]
async fn main() {
    let counter = Arc::new(SharedCounter {
        value: Mutex::new(0),
    });
    
    let mut handles = vec![];
    
    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        handles.push(tokio::spawn(async move {
            counter.increment().await;
        }));
    }
    
    for handle in handles {
        handle.await.unwrap();
    }
    
    println!("Counter: {}", counter.get().await);
}

三、异步IO操作

3.1 文件操作

use tokio::fs;

async fn read_file(path: &str) -> Result<String, std::io::Error> {
    fs::read_to_string(path).await
}

async fn write_file(path: &str, content: &str) -> Result<(), std::io::Error> {
    fs::write(path, content).await
}

#[tokio::main]
async fn main() -> Result<(), std::io::Error> {
    let content = read_file("input.txt").await?;
    write_file("output.txt", &content).await?;
    Ok(())
}

3.2 TCP通信

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

async fn handle_client(mut socket: TcpStream) {
    let mut buf = [0; 1024];
    
    loop {
        match socket.read(&mut buf).await {
            Ok(0) => break,
            Ok(n) => {
                if socket.write_all(&buf[0..n]).await.is_err() {
                    break;
                }
            }
            Err(_) => break,
        }
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
    
    loop {
        let (socket, _) = listener.accept().await?;
        tokio::spawn(handle_client(socket));
    }
}

四、并发模式

4.1 并行执行

use tokio;

async fn fetch_url(url: &str) -> String {
    println!("Fetching {}", url);
    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    format!("Data from {}", url)
}

#[tokio::main]
async fn main() {
    let urls = vec!["https://api1.example.com", "https://api2.example.com", "https://api3.example.com"];
    
    // 创建所有任务
    let tasks = urls.iter().map(|url| fetch_url(url));
    
    // 并发执行
    let results = tokio::join_all(tasks).await;
    
    for result in results {
        println!("{}", result);
    }
}

4.2 超时处理

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

async fn slow_operation() {
    tokio::time::sleep(Duration::from_secs(5)).await;
}

#[tokio::main]
async fn main() {
    match timeout(Duration::from_secs(2), slow_operation()).await {
        Ok(_) => println!("Operation completed"),
        Err(_) => println!("Operation timed out"),
    }
}

4.3 信号量控制

use tokio::sync::Semaphore;
use std::sync::Arc;

async fn limited_task(semaphore: Arc<Semaphore>, id: usize) {
    let permit = semaphore.acquire().await.unwrap();
    println!("Task {} started", id);
    tokio::time::sleep(Duration::from_secs(1)).await;
    println!("Task {} completed", id);
    drop(permit);
}

#[tokio::main]
async fn main() {
    let semaphore = Arc::new(Semaphore::new(3));
    
    let mut handles = vec![];
    
    for i in 0..10 {
        let semaphore = Arc::clone(&semaphore);
        handles.push(tokio::spawn(limited_task(semaphore, i)));
    }
    
    for handle in handles {
        handle.await.unwrap();
    }
}

五、异步最佳实践

5.1 避免阻塞

// 错误:阻塞调用
async fn bad_example() {
    std::thread::sleep(Duration::from_secs(1)); // 阻塞!
}

// 正确:使用异步sleep
async fn good_example() {
    tokio::time::sleep(Duration::from_secs(1)).await; // 非阻塞
}

// 使用block_in_place处理阻塞操作
async fn handle_blocking() {
    let result = tokio::task::spawn_blocking(|| {
        // 阻塞操作
        expensive_computation()
    }).await.unwrap();
}

5.2 任务取消

use tokio::task;

async fn long_running() {
    for i in 0..10 {
        tokio::time::sleep(Duration::from_secs(1)).await;
        println!("Progress: {}/10", i + 1);
        task::yield_now().await;
    }
}

#[tokio::main]
async fn main() {
    let handle = tokio::spawn(long_running());
    
    tokio::time::sleep(Duration::from_secs(3)).await;
    handle.abort();
    
    match handle.await {
        Ok(_) => println!("Completed"),
        Err(_) => println!("Cancelled"),
    }
}

5.3 资源清理

use tokio::sync::oneshot;

async fn worker(mut shutdown: oneshot::Receiver<()>) {
    loop {
        tokio::select! {
            _ = &mut shutdown => {
                println!("Shutting down");
                break;
            }
            _ = tokio::time::sleep(Duration::from_secs(1)) => {
                println!("Working...");
            }
        }
    }
}

#[tokio::main]
async fn main() {
    let (tx, rx) = oneshot::channel();
    
    tokio::spawn(worker(rx));
    
    tokio::time::sleep(Duration::from_secs(3)).await;
    tx.send(()).unwrap();
}

六、性能优化

6.1 任务调度优化

use tokio::task::LocalSet;

#[tokio::main]
async fn main() {
    let local = LocalSet::new();
    
    local.run_until(async {
        // 在此上下文中生成的任务都在当前线程上执行
        tokio::task::spawn_local(async {
            println!("Local task");
        }).await.unwrap();
    }).await;
}

6.2 内存优化

use tokio::io::AsyncWriteExt;

async fn write_large_data() -> Result<(), std::io::Error> {
    let mut file = tokio::fs::File::create("large_file.txt").await?;
    
    // 使用write_all_buf避免内存拷贝
    let data = vec![0u8; 1024 * 1024];
    file.write_all(&data).await?;
    
    Ok(())
}

七、总结

Rust异步运行时的关键要点:

  1. Tokio:最成熟的异步运行时,适合生产环境
  2. async/await:简洁的异步语法
  3. 任务管理:spawn、join_all、select等工具
  4. 并发控制:Semaphore、Mutex等同步原语
  5. 避免阻塞:使用异步替代同步操作

在实际项目中,建议:

  • 使用Tokio作为默认运行时
  • 避免在异步代码中调用阻塞函数
  • 使用适当的并发控制机制
  • 注意任务取消和资源清理

思考:在你的Rust项目中,异步编程带来了哪些性能提升?欢迎分享!

Tokio异步运行时,Tokio的多线程调度器架构 Tokio多线程调度器采用M:N模型,其核心在于本地LIFO队列和全局FIFO队列相结合的"工作窃取"机制。本地LIFO(后进先出)提升缓存局部性,优先执行刚完成的任务以利用热数据;窃取时采用FIFO(先进先出)减少线程间缓存争用,窃取较冷的旧任务。此外,Tokio采用协作式调度,需要开发者通过yield_now主动让出控制权,避免CPU密集型任务导致的任务饥饿问题。这种设计在缓存效率、负载均衡和公平性之间实现了精妙平衡,是高性能Rust异步编程的关键基础。 阅读详情

相关推荐

Rust异步运行时框架tokio保姆级教程

Tokio 是一个用于构建高性能异步应用程序的 Rust 异步运行时框架。它提供了基本的异步 I/O 操作、任务调度、定时器等功能,适合于构建网络服务器、客户端等。Tokio 提供了强大的工具来进行异步编程。使用它,可以轻松构建高性能的网络应用。

2301_78960337的博客 3088

Rust Axum+sea-orm避坑指南:异步数据库连接那些事儿

本文详细介绍了在Rust生态中使用Axum框架和sea-orm进行异步数据库连接的避坑指南。从异步运行时选择、连接池配置到错误处理和性能优化,提供了实战经验和最佳实践,帮助开发者避免常见陷阱,提升Web服务的高并发处理能力。

weixin_30772105的博客 387

[MR]RCM约束下的手术机器人

RCM(Remote Center of Motion)约束,通俗讲就是做微创手术时,机械臂插进身体,机械臂受身体的插入点的约束,不能乱动。 相关参考论文 Task Control with Remote Center of Motion Constraint for Minimally Invasive Robotic Surgery ...

土豆大叔的博客 4585

异步运行时迁移先保留可回退路径

把同步函数整体塞进 async 并不会自动变快。迁移文件读取流程时,我先保留旧实现,用 feature flag 切换,再比较同一份虚构输入的结果。每次只替换一个 I/O 点,并为失败保留原始错误上下文。CPU 密集型解析不该长期占用 Tokio worker,需要单独评估。这里的比较只是本机练习,不拿单次耗时当性能结论。

no1coder的博客 4292

SAP Business One自定义表与字段实战:从零构建企业专属数据模型

本文详细介绍了如何在SAP Business One中创建自定义表与字段,从零构建企业专属数据模型。通过实战案例和避坑指南,帮助用户掌握业务适配、流程优化和权限隔离等关键技巧,提升系统灵活性和数据管理效率。特别适合需要扩展标准功能的SAP Business One用户。

weixin_28730927的博客 365

【技术解析】华为智算中心:昇腾AI算力与无损网络如何驱动大模型训练

本文深入解析了华为智算中心如何通过昇腾AI算力与超融合以太无损网络的协同,驱动千亿参数大模型的高效训练。昇腾NPU提供专用计算引擎,而基于RoCE的无损网络则通过PFC、ECN等技术确保万卡集群间的高带宽、零丢包通信,实现算力利用率最大化,解决大规模AI训练的核心瓶颈。

weixin_29311017的博客 204

AI 辅助:Tokio 异步编程入门:任务并发不是线程越多越好

Tokio 异步编程适合 I/O 密集并发,通过任务让出执行权提升资源利用率。它不是线程越多越好,也不适合直接承载 CPU 密集工作。限制并发、处理超时和避免持锁 await,是写稳异步代码的基础。

no1coder的博客 5871

python爬虫抖音 个人资料 仅供学习参考 切勿用于商业

本文仅供学习参考 切勿用于商业 本次爬取使用fiddler+模拟器(下载抖音APP)+pycharm 1. 下载最新版本的fiddler(自行百度下载),以及相关配置 1.1.依次点击,菜单栏-Tools-Options-HTTPS,如图1红框打钩,HTTPS旁边Connections配置,如图2红框打钩 1.2.再次点击HTTPS栏,点击Actions选择第二个…to ...

dbva7063的博客 1491

终极指南:用Tokio实现Ctrl+C优雅关闭的5个实战技巧

你是否曾遇到过这样的问题:服务器收到Ctrl+C信号后直接崩溃,导致数据丢失或连接未正常关闭?作为Rust异步运行时的领军者,Tokio([Cargo.toml](https://link.gitcode.com/i/fb0d1801308bfec67ad5b4dc59228902))提供了强大的信号处理机制,让你的应用能够优雅地应对中断。本文将通过5个实用技巧,带你掌握如何在Tokio应用中实现...

gitblog_00005的博客 421

当MATLAB遇见ROS2:一场跨平台实时仿真的技术融合与创新实践

本文探讨了MATLAB/Simulink与ROS2在跨平台实时仿真中的技术融合与创新实践。重点介绍了在Windows+WSL2异构环境下构建高可靠性联合仿真系统的架构设计、PX4仿真环境与DDS中间件的集成方法,以及MATLAB R2024b对ROS2深度集成的实战技巧,为复杂机器人系统的开发提供了高效解决方案。

rum55的博客 249

【Neo4j × Python】基于知识图谱的电影问答系统(含问题记录与解决)附:源代码(含Bug解决)

此前,曾介绍过Neo4j的一些基础知识,本篇将在PyCharm中与Neo4j建立关联,从0到1实现一个基于知识图谱的电影问答系统,实现过程中,没有一帆风顺,而是遇到了一些问题,因此也包含问题的记录与解决。

追光者♂:记录、分享、总结、提升,现象级专栏《Python从入门到人工智能》作者,无惧黑暗,坚信曙光 3168

Rust深入异步运行时:Tokio的内部原理与性能调优

本文深入探讨了Rust异步运行时Tokio的内部原理与性能优化。Tokio采用三层架构设计,包含核心层(调度器、I/O驱动、任务系统)、中间层(网络/文件/定时器API)和应用层(async/await语法)。核心组件解析了多线程/单线程调度器的工作机制、I/O驱动的事件循环原理以及任务系统的Future/Waker实现。文章通过代码示例展示了任务调度流程,并对比了多线程与单线程调度器的适用场景,为开发者理解Tokio底层原理和性能调优提供了实践指导。

编程世界如山海,探索不止。 1万+

浏览器缓存导致代码不更新?一招解决部署后用户仍看到旧页面的问题

方案效果适用场景文件名哈希永久解决前端工程化项目HTTP缓存头控制精准控制需服务器权限Meta标签部分生效临时补救方案最佳实践:入口HTML禁用缓存,静态资源使用哈希文件名 + 长期缓存,达到「秒级更新」+「高性能」的平衡!

江拥羡橙的博客 815

Rust 异步运行时横向对比:Tokio、async-std、smol、glommio 的实测数据

我第一次用 Rust 写异步代码的时候,直接,然后就开始写了。那时候我觉得,异步运行时不就是个async-std吗?有啥好选的?直到我的项目在生产环境出现了诡异的——有时候 10ms 就能完成的任务,偶尔会卡 500ms。查了三天日志,最后发现是 Tokio 的 work-stealing 调度器在我的场景下出现了。那一刻我意识到:异步运行时不是"能跑就行",它直接决定了你的服务是还是。选错了运行时,轻则性能不佳,重则生产事故。下面我用实测数据说话。

no1coder的博客 4395

【数据分享】2012-2022年全国及各城市POI(兴趣点)数据(超20G)

POI(一般作为Point of Interest的缩写,也有Point of Information的说法),通常称作兴趣点,泛指互联网电子地图中的点类数据,基本包含名称、地址、坐标、类别四个属性;随着互联网电子地图服务与LBS应用的普及,POI无论从概念范畴,还是从信息纵深都有了长足发展,互联网各个风口或火山口都和POI有一定关系,如O2O、电商、社交、互联网金融、共享经济等。

J_Giser的博客 2744

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

Rust异步并发编程tokio异步运行时讲解和使用,新手必学

Rust 在v1.39版本以后就引入了async关键字,用于支持异步编程。Rust中,async函数或块会被视作一个 Future 对象,async 关键字只是用来定义这个 Future 对象,定义好的这片异步代码并不会自动执行,而是需要和 async 配对的 .await 去驱动它才会执行。用 async 定义异步代码,用 .await 驱动执行。但是 .await 又只能在 async 块中调用。Rust 明确规定了,main 函数前不能加 async 修饰。也就是说,只能写成这种形式。

2580

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

Tokio 在生产环境:日处理千万请求的异步服务怎么配置才稳妥

这篇文章复盘了 Tokio 从开发环境到生产环境的配置要点:runtime 参数需要根据服务器实际情况调优(worker_threads 留余量给 sidecar,max_blocking_threads 根据 spawn_blocking 用量调整),Semaphore 做 per-endpoint 限流防止单点过载拖垮全局,通过+ GracefulShutdown 实现安全的重启流程。日处理千万请求不是一个很难的数字,但要做到"稳妥"确实需要把这些细节都处理好。

no1coder的博客 2260

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

Rust Tokio 框架源码解析:基于异步运行时的高并发编程实践

介绍了 Tokio 在 Rust 异步生态中的基础设施定位,重点分析了其基于 Future trait 和 Waker 机制的异步编程模型。

Abin 2730

从 Python asyncio 到 Rust Tokio:异步运行时的底层机制与实战对比

Python asyncio 和 Rust Tokio 虽然都使用语法,但底层调度模型截然不同:前者是单线程事件循环,后者是多线程工作窃取调度器。这种差异直接导致了 Rust 异步代码中Send约束和所有权问题的出现。从 asyncio 迁移到 Tokio 时,需要放弃"协程天然线程安全"的假设,转而用 Rust 的类型系统来保证并发正确性。对于 I/O 密集型、低并发场景,Python asyncio 仍然是高效的选择;

no1coder的博客 5653

【Rust 探索之旅】Tokio 异步运行时完全指南:深入理解 Rust 异步编程与源码实现

在处理高并发场景时,我深刻体会到异步编程的威力。我们的大数据处理项目迁移到 Tokio 后,在相同硬件下吞吐量提升了 3 倍,P99 延迟降低了 60%。Tokio 不仅是 Rust 生态中最重要的异步运行时,更是现代高性能系统的基石。本文将深入 Tokio 源码,从 Runtime 调度器到 I/O 驱动器,从定时器系统到任务管理,全面剖析其设计精髓。我将结合实际项目经验,通过大量代码示例和真实案例,帮助你理解 Tokio 的工作原理。

白鹿第一帅的 优快云 博客 2568

Rust异步框架tokio开发实践

tokio的实现学习了go,以go这门为异步而生的工具为目标,相信tokio一样能扛起Rust异步编程的大旗。

qq_50764711的博客 1418

Rust异步运行时生态:Tokio与竞品的深度对比分析

在Rust异步编程领域,运行时的选择往往决定了应用的性能特征和开发体验。Tokio作为事实上的标准,占据了绝对主导地位,但async-std、smol等运行时也各有千秋。本文将从架构设计、性能特性到实际应用场景,全面对比主流Rust异步运行时,帮助开发者做出明智的技术选型。

Y122000的博客 1048

Tokio —— Rust 异步运行时框架指南

Tokio —— Rust 异步运行时框架指南 【免费下载链接】tokio A runtime for writing reliable asynchronous applications with Rust. Provides I/O, networking, scheduling, timers, ... ...

gitblog_00836的博客 981

Tokio Rust异步运行时入门教程

Tokio是Rust生态中最流行的异步运行时库,专为高性能网络应用设计。本文介绍了Tokio的核心功能和基本使用方法: Tokio通过异步I/O和轻量级任务实现高并发性能,支持百万级并发连接 基本使用包括添加依赖、创建异步主函数和构建TCP服务器 核心概念包括任务管理、异步I/O操作和通道通信 高级特性涉及选择器、资源池和速率限制 需避免阻塞运行时等常见陷阱 Tokio结合Rust的安全特性,为构建高效可靠的异步应用提供了强大支持,是网络应用开发的理想选择。

securityspher的博客 821

Tokio:Rust 异步界的 “霸主”

在 Rust 异步编程生态中,Tokio 是当之无愧的核心支柱

码刀攻城 1908

深入 Tokio:Rust 异步运行时的 I/O 事件循环实现机制

在真实 Tokio 中,这段逻辑会被扩展为:注册 socket、timer、signal 等资源;关联 Waker 唤醒逻辑;将事件转换为任务调度信号。这种机制让 Tokio 不仅是一个运行时,更是一个底层事件驱动内核(Event-Driven Kernel)。显式控制 + 零抽象开销:事件注册与唤醒过程全由编译期确定,无 GC 负担;跨平台统一性:通过mio抽象屏蔽底层差异;确定性并发:基于 Poll 的模型让每一步都可追踪、可优化;生态支撑。

hl826669的博客 1171
上一篇: Rust Trait系统深度解析:从基础到高级应用
下一篇: Rust Cargo工作空间:项目组织与依赖管理
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值