Rust 异步编程实战:构建高性能并发应用

《Rust 实战指南》第 10 章:异步编程——C10K 问题的终极解法 对于 Java 开发者(熟悉线程池/Future)和 Python 开发者(熟悉 asyncio),Rust 的异步模型既有熟悉的影子,又有本质的区别(如惰性执行)。本章将通过对比和实战,彻底讲透如何利用 Tokio 运行时榨干 CPU 的性能。 阅读详情

Rust 异步编程实战:构建高性能并发应用

什么是异步编程?

异步编程是一种编程范式,它允许程序在等待某些操作(如I/O操作)完成时继续执行其他任务,而不是阻塞等待。在Rust中,异步编程主要通过async和await关键字,以及Future trait来实现。

基本概念

协程

在Rust中,协程是通过async关键字定义的函数,它返回一个Future对象。

async fn say_hello() {
    println!("Hello");
    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
    println!("World");
}

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

Future

Future是一个 trait,它表示一个异步操作的最终结果。当一个异步操作完成时,Future会被解析为其结果。

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

struct Delay {
    duration: Duration,
    elapsed: Duration,
}

impl Future for Delay {
    type Output = ();
    
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let this = self.get_mut();
        if this.elapsed >= this.duration {
            Poll::Ready(())
        } else {
            // 注册唤醒
            let waker = cx.waker().clone();
            std::thread::spawn(move || {
                std::thread::sleep(Duration::from_millis(100));
                waker.wake();
            });
            this.elapsed += Duration::from_millis(100);
            Poll::Pending
        }
    }
}

async fn async_task() {
    println!("开始异步任务");
    Delay { duration: Duration::from_secs(1), elapsed: Duration::from_secs(0) }.await;
    println!("异步任务完成");
}

fn main() {
    futures::executor::block_on(async_task());
}

使用Tokio

Tokio是Rust最流行的异步运行时,它提供了事件循环、任务调度、网络I/O等功能。

基本用法

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

async fn task1() {
    println!("任务1开始");
    sleep(Duration::from_secs(1)).await;
    println!("任务1完成");
}

async fn task2() {
    println!("任务2开始");
    sleep(Duration::from_secs(1)).await;
    println!("任务2完成");
}

async fn async_main() {
    // 并发执行多个异步任务
    tokio::join!(task1(), task2());
    println!("所有任务完成");
}

fn main() {
    tokio::runtime::Builder::new_multi_thread()
        .build()
        .unwrap()
        .block_on(async_main());
}

异步I/O

use tokio::fs::File;
use tokio::io::{self, AsyncReadExt, AsyncWriteExt};

async fn read_file() -> io::Result<()> {
    let mut file = File::open("hello.txt").await?;
    let mut contents = String::new();
    file.read_to_string(&mut contents).await?;
    println!("文件内容: {}", contents);
    Ok(())
}

async fn write_file() -> io::Result<()> {
    let mut file = File::create("hello.txt").await?;
    file.write_all(b"Hello, World!").await?;
    println!("文件写入成功");
    Ok(())
}

#[tokio::main]
async fn main() -> io::Result<()> {
    write_file().await?;
    read_file().await?;
    Ok(())
}

高级用法

任务管理

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

async fn long_running_task() {
    println!("长时间运行的任务开始");
    for i in 0..5 {
        println!("工作中... {}", i);
        sleep(Duration::from_secs(1)).await;
    }
    println!("长时间运行的任务完成");
}

#[tokio::main]
async fn main() {
    // 创建任务
    let task = task::spawn(long_running_task());
    
    // 等待一段时间后取消任务
    sleep(Duration::from_secs(2)).await;
    println!("取消任务");
    task.abort();
    
    // 等待任务完成或被取消
    match task.await {
        Ok(_) => println!("任务正常完成"),
        Err(e) => println!("任务被取消: {:?}", e),
    }
}

超时处理

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

async fn long_running_task() {
    println!("长时间运行的任务开始");
    sleep(Duration::from_secs(5)).await;
    println!("长时间运行的任务完成");
    "成功"
}

#[tokio::main]
async fn main() {
    let result = timeout(Duration::from_secs(2), long_running_task()).await;
    
    match result {
        Ok(value) => println!("任务结果: {}", value),
        Err(_) => println!("任务超时"),
    }
}

流(Streams)

use tokio::stream::{self, StreamExt};

#[tokio::main]
async fn main() {
    // 创建一个流
    let mut stream = stream::iter(vec![1, 2, 3, 4, 5]);
    
    // 遍历流
    while let Some(item) = stream.next().await {
        println!("流元素: {}", item);
    }
    
    // 转换流
    let mut stream = stream::iter(vec![1, 2, 3, 4, 5])
        .map(|x| x * 2)
        .filter(|x| *x > 5);
    
    while let Some(item) = stream.next().await {
        println!("转换后的流元素: {}", item);
    }
}

实用应用

异步Web服务器

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

async fn handle_connection(mut socket: tokio::net::TcpStream) {
    let mut buffer = [0; 1024];
    
    // 读取请求
    let n = socket.read(&mut buffer).await.unwrap();
    println!("收到请求: {}", String::from_utf8_lossy(&buffer[0..n]));
    
    // 发送响应
    let response = "HTTP/1.1 200 OK\r\nContent-Length: 12\r\n\r\nHello World!";
    socket.write_all(response.as_bytes()).await.unwrap();
}

#[tokio::main]
async fn main() {
    let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();
    println!("服务器启动在 http://127.0.0.1:8080");
    
    loop {
        let (socket, _) = listener.accept().await.unwrap();
        tokio::spawn(async move {
            handle_connection(socket).await;
        });
    }
}

异步数据库操作

use tokio_postgres::NoTls;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 连接数据库
    let (client, connection) = tokio_postgres::connect(
        "host=localhost user=postgres password=password dbname=test",
        NoTls,
    ).await?;
    
    // 后台运行连接
    tokio::spawn(async move {
        if let Err(e) = connection.await {
            eprintln!("连接错误: {:?}", e);
        }
    });
    
    // 创建表
    client.execute(
        "CREATE TABLE IF NOT EXISTS users (id SERIAL PRIMARY KEY, name TEXT, email TEXT)",
        &[],
    ).await?;
    
    // 插入数据
    client.execute(
        "INSERT INTO users (name, email) VALUES ($1, $2)",
        &[&"Alice", &"alice@example.com"],
    ).await?;
    
    // 查询数据
    let rows = client.query(
        "SELECT * FROM users",
        &[],
    ).await?;
    
    for row in rows {
        let id: i32 = row.get(0);
        let name: &str = row.get(1);
        let email: &str = row.get(2);
        println!("用户: id={}, name={}, email={}", id, name, email);
    }
    
    Ok(())
}

异步HTTP客户端

use reqwest::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    
    // 发送GET请求
    let response = client.get("https://api.github.com")
        .send()
        .await?;
    
    // 读取响应
    let body = response.text().await?;
    println!("响应长度: {}", body.len());
    
    // 并发发送多个请求
    let urls = [
        "https://api.github.com",
        "https://api.twitter.com",
        "https://api.google.com"
    ];
    
    let mut tasks = vec![];
    for url in &urls {
        let client = client.clone();
        let task = tokio::spawn(async move {
            let response = client.get(url).send().await?;
            Ok((url, response.text().await?))
        });
        tasks.push(task);
    }
    
    for task in tasks {
        let (url, body) = task.await??;
        println!("URL: {}, 响应长度: {}", url, body.len());
    }
    
    Ok(())
}

最佳实践

1. 合理使用await

只有在需要等待结果时才使用await,否则会阻塞当前协程的执行。

2. 避免阻塞操作

在异步代码中,应避免使用阻塞操作,如std::thread::sleep,而应使用对应的异步版本,如tokio::time::sleep。

3. 合理使用任务

对于需要并发执行的操作,应使用tokio::spawn创建任务,而不是顺序执行。

4. 正确处理错误

使用Result类型和?操作符处理异步错误。

5. 注意内存使用

对于处理大量数据的异步操作,应注意内存使用,避免内存泄漏。

总结

Rust的异步编程是一种强大的并发编程方式,它通过async和await关键字,以及Future trait,提供了一种高效、简洁的方式来处理并发任务。通过使用Tokio等异步运行时,我们可以构建高性能的异步应用程序,特别是在处理I/O密集型任务时。

在实际开发中,异步编程常用于:

  • Web服务器和API
  • 数据库操作
  • 网络爬虫和API调用
  • 实时通信应用
  • 数据流处理

通过掌握Rust的异步编程技术,我们可以编写更加高效、可靠的Rust代码,提升应用的性能和用户体验。

掌握异步编程:Rust语言的并发之道 本文深入探讨了Rust语言中的异步编程概念,包括并发程序的编写、异步Rust的深入理解、Futures的原理以及自定义Future的实现。通过实例讲解了并发和并行的区别,并分析了多线程和异步编程在处理并发请求时的优劣。文章强调了异步编程在提升Web服务器处理大量并发请求效率方面的重要性,并提供了Rust异步编程的高级概念。 阅读详情

相关推荐

DSMA时序修复避坑指南:当Setup和Hold互卡时,除了调Margin还能做什么?

本文深入探讨DSMA时序修复中的Setup与Hold互锁问题,提供7种高阶策略,包括优先级判断、高级参数组合、单元类型智能替换等,帮助工程师突破时序收敛瓶颈。特别针对fix_eco_timing命令的隐藏参数和物理协同优化进行详细解析,助力芯片设计实现时序收敛。

weixin_30162121的博客 299

Rust异步编程实战:构建高性能并发应用

);Rust的异步编程提供了高性能的并发模型,通过Tokio运行时实现高效的任务调度。与Python相比,Rust的异步编程更加显式和类型安全。async/await语法:简洁的异步代码写法Tokio运行时:强大的异步执行引擎并发模式:并行任务、流处理、同步原语性能优化:避免阻塞、使用spawn_blocking、批量操作错误处理:使用Result类型进行显式错误处理通过掌握Rust异步编程,你可以构建出高性能、高可靠性的后端服务。参考资料。

no1coder的博客 4426

VS(QT)调用Matlab函数的方法

调试–>窗口–>异常设置–>Win32 Exceptions全部不要勾选。选择Microsoft Visual C++ 2017。将生成的.h和.lib分别放置在对应的文件夹。输入mex -setup C++输入deploytool选择。选择Realse x64。

woshigaowei5146的博客 592

【Rust异步】async和await异步编程实战:高并发任务处理全解析

async 和 await 是 Rust 中用于异步编程的关键字。 async 用于定义异步函数,表示函数体中包含异步代码。 await 用于等待异步操作完成,并返回异步操作的结果。 • 异步函数使用 async 关键字定义,并返回实现了 Future Trait 的类型。 异步函数可以在其他异步函数中使用 await 关键字等待异步操作完成。 调用异步函数时,会返回一个实现了 Future Trait 的对象,可以通过调用.await 方法等待结果。

景天科技苑 2万+

Quartus Prime v18.1 standard-QuartusPrimeV18.1标准版安装过程

Quartus Prime v18.1 standard安装破解过程 下载方式1:官网下载: https://fpgasoftware.intel.com/18.1/?edition=standard&platform=windows 下载方式2:可以从我的网盘下载安装包(如果链接未时效的话): 链接:https://pan.baidu.com/s/1bq4_FcNPSflU1zGJv__rvA 提取码:o0in ----------------------------------.

Alonger1988的博客 2万+

Dify 从入门到熟悉100 天的学习大纲

理解 Dify 的核心概念,熟悉操作界面,并能创建简单的 AI 应用。祝你在这 100 天的旅程中学有所成,成为一名优秀的 AI 应用开发者!掌握生产环境部署、监控、调优,并关注 Dify 生态和前沿动态。探索多模态、Agent、API 集成、性能优化等高级主题。掌握工作流编排、高级提示词技巧、知识库优化等核心功能。

IT深耕十余载,大道之简 1737

Rust异步编程实战:构建高性能网络应用

本文介绍了Rust异步编程的核心概念与实践方法。首先对比了同步与异步编程的区别,阐述了异步编程在高并发场景下的优势。随后详细讲解了Rust异步编程的演进历程,重点介绍了Future、Poll和Waker三个核心概念。文章通过代码示例展示了async/await语法的使用方式,包括异步函数的定义和执行流程。最后深入讲解了Tokio异步运行时的架构、安装配置方法,并提供了TCP服务器/客户端的实现示例,帮助开发者掌握Rust高性能网络应用的构建方法。

编程世界如山海,探索不止。 9679

冒泡排序的并行计算

本人也是并行计算的小白,在这里记录下自己的学习笔记。 今天做了一下冒泡排序的并行计算比较: 串行冒泡排序如下: #include <stdio.h> #include <stdlib.h> #include <windows.h> void BubbleSort(int * pData, int nSize) { if (!pData) { ...

gaoyi的专栏 4494

Rust异步编程实战:构建高性能WebSocket服务

本文介绍了使用Rust构建高性能WebSocket服务的实战方法。首先概述了WebSocket协议的特点,包括全双工通信、低延迟等优势,并对比了WebSocket与HTTP的区别。然后详细讲解了如何使用Axum框架实现WebSocket服务端,包括连接建立、消息处理和连接关闭等核心功能。文章还展示了如何通过tokio的broadcast通道实现多连接管理和消息广播功能,为构建实时应用提供了完整解决方案。示例代码涵盖了欢迎消息发送、消息回复、Ping/Pong处理等关键环节,并集成了日志记录功能,为开发者提供

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

五步通关!宝塔Linux部署ASP.NET Core的魔法秘籍大公开!

摘要: 本文提供ASP.NET Core应用五步部署攻略,涵盖从环境配置到线上运行的完整流程: 1️⃣ 环境准备:安装宝塔面板、ASP.NET Core运行时及开放端口; 2️⃣ 应用发布:通过dotnet publish生成独立部署包并上传服务器; 3️⃣ Nginx配置:设置反向代理将域名请求转发至应用端口; 4️⃣ 进程守护:使用Supervisor确保应用持续运行; 5️⃣ HTTPS加密:通过宝塔快速申请SSL证书并解决验证路径冲突。 关键点: 强调权限设置(755)、端口开放及反向代理细节; 提

java专栏 970

华为OD机考双机位C卷 - 最左侧冗余覆盖子串 (Java)

华为OD机考双机位C卷 - 最左侧冗余覆盖子串 (Java), 提供Java、C++、Python、Go、JavaScript源码实现,并提供完整思路讲解,以及在线OJ模拟做题。

算法大师! 59

Rust异步编程与Tokio运行时:构建高性能Web应用

本文介绍了Rust语言的异步编程特性和Tokio运行时,如何构建高性能的Web应用。我们了解了Rust的并发模型,异步编程,性能优化,以及如何使用Tokio创建异步HTTP服务器。最后探讨了如何进行性能调优,以确保应用运行得尽可能高效。

silenceallat的博客 1597

ESP32学习笔记06-UART 的485 通讯模式

通信方式选择UART 控制器支持多种通信模式,使用函数 uart_set_mode() 可以选择模式。选择特定模式后,UART 驱动程序将处理已连接 UART 设备的相应行为。例如,主机开始向 Tx FIFO 缓冲区写入数据时,UART 驱动程序会自动置位 RTS 管脚(逻辑 1);最后一位数据传输完成后,驱动程序就会取消置位 RTS 管脚(逻辑 0)。要使用此模式,软件。

Car12 2477

Rust Web实战:构建高性能并发工具的艺术

Rust语言凭借其独特的所有权系统和零成本抽象特性,成为构建高性能Web应用的理想选择。本文系统介绍了Rust在Web高并发领域的应用实践,包括:1)Tokio异步运行时的核心原理与并发原语;2)Actix-Web框架的高性能实现机制;3)分布式计数器服务的完整开发案例;4)性能优化策略与多语言对比测试。通过内存安全保证、无畏并发特性和接近底层的执行效率,Rust在Web开发领域展现出独特优势,为构建下一代高性能Web服务提供了可靠的技术基础。

laozhangguzhang的博客 1282

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

Rust 异步编程:使用 Tokio 构建高性能异步应用

异步编程是一种允许程序在等待 I/O 操作、网络请求或其他耗时任务完成时,不阻塞主线程,继续执行其他任务的编程范式。在传统的同步编程中,当程序执行到一个耗时操作时,主线程会被阻塞,直到该操作完成,这会导致系统资源的浪费和响应性能的下降。而异步编程通过引入回调、Promise、Future 等机制,使得程序在等待任务完成的同时,可以继续处理其他任务,从而提高系统的并发处理能力和整体性能。Tokio 是一个基于 Rust 的异步运行时,它提供了一系列用于异步编程的核心组件,包括任务调度、I/O 处理、定时器等。

数字魔方操控师的博客 1351

温度PID控制PLC程序

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

Rust异步编程入门与实战:从理论到实践

在开始之前,我想先聊聊什么是异步编程。异步编程是一种编程范式,它允许程序在等待某些操作(如网络请求、文件I/O等)完成时,继续执行其他任务,而不是阻塞等待。传统的同步编程模型中,当我们执行一个耗时操作时,程序会一直等待这个操作完成,然后才继续执行下一步。这种方式在处理并发任务时效率较低,因为CPU在等待I/O操作时处于空闲状态。而异步编程模型中,当我们执行一个耗时操作时,程序会注册一个回调函数,然后继续执行其他任务。当耗时操作完成时,系统会通知程序,然后执行相应的回调函数。

no1coder的博客 1万+

Rust 并发实战:使用 Tokio 构建高性能异步 TCP 聊天室

本文通过构建一个基于Rust异步生态(tokio)的TCP聊天室,探讨了Rust在高并发网络编程中的独特优势。传统语言(如C++/Java/Go)在性能、安全性和开发效率之间难以平衡,而Rust通过“无畏并发”理念,结合async/await和tokio运行时,实现了零成本抽象与编译时并发安全。 文章详细解析了聊天室的核心实现: 异步模型:利用tokio的多线程运行时和broadcast通道实现高效广播; 并发安全:通过Send/Sync特性及所有权系统避免数据竞争; 性能对比:相比Node.js的

kevin_blog 5532

【Rust实战】从零构建高性能异步Web服务器:深入理解所有权与生命周期

本文通过实战项目讲解如何使用Rust构建高性能异步Web服务器。文章从Rust的核心特性(所有权系统、生命周期、异步编程)入手,详细介绍了基于Tokio运行时的服务器架构设计与实现。主要内容包括: Rust优势分析:对比多种语言性能,展示Rust在内存安全和并发处理上的优势,实测QPS达52,341。 核心技术回顾:深入讲解所有权转移、借用规则、生命周期标注等Rust核心概念。 项目架构:采用分层设计实现高性能服务器,包含TCP监听、路由分发、请求处理等模块。 完整实现:提供可运行的项目源码,涵盖连接池、异

2302_80663569的博客 1317

【Rust异步编程实战指南】:掌握零成本抽象下的高性能并发设计

掌握rust异步编程核心技巧,解决高并发场景下的性能瓶颈。涵盖Future、async/await使用、Tokio运行时优化,实现零成本抽象与高效资源利用。适用于网络服务、实时系统开发,值得收藏。

FuncFun的博客 734

Rust 异步编程实战

在复杂的应用中,定义自定义错误类型可以提高代码的可读性和可维护性。write!(f, "{:?}", self)async-std提供了一个简化的异步编程接口,与 Rust 标准库接口相似,使得异步编程更易于理解。println!("获取的数据: {}", data);});Tokio是一个功能强大的异步运行时,适用于构建 I/O 密集型应用。它支持异步 I/O、任务调度和定时器等功能。// 模拟异步延迟println!("延迟完成");

好看资源网的博客 1182

Rust 异步编程详解(async/await)

Rust异步编程通过async/await语法和Future trait实现高效I/O处理,核心机制包括状态机模型和运行时调度。文章详细解析了异步编程基础、核心组件(Future trait、async/await语法)、工作流程,并提供了HTTP请求等代码示例。同时探讨了错误处理、任务取消、Pin/Unpin等高级话题,比较了不同运行时的适用场景。最佳实践建议选择合适运行时、避免阻塞操作,并指出异步编程在性能和安全方面的优势,以及调试复杂度等限制。附带的并发网络请求示例展示了tokio运行时的实际应用,包

本博客分享软硬件一体化开发实战。硬件涵盖 PCB 设计、STM32 等 MCU 底层开发;软件包含 C++、Rust,Qt/QML、PyQt、Slint、TouchGFX、LVGL 各类 GUI 框架。方便软硬件开发者查阅学习。欢迎关注! 2225

Rust Async 异步编程(一):入门

Rust Async 异步编程(一):入门

ProgramNovice的博客 1389

MCP初学者终极指南:从零开始构建Rust异步编程实战

Model Context Protocol (MCP) 是一个开源课程,专门设计用于教授模型上下文协议的概念和基础知识,提供.NET、Java和Python的实际示例。对于想要掌握现代AI应用开发的开发者来说,这是一个完美的起点。 ## 什么是MCP?为什么它如此重要? MCP(Model Context Protocol)是一种标准化的协议,用于在AI应用和工具之间建立通信。它让AI代理能

gitblog_00978的博客 947

Rust:异步编程与并发安全的深度实践

Rust:异步编程与并发安全的深度实践

啊Q老师 1194

Web开发与异步编程:Awesome Rust Streaming中的现代Web技术直播

Awesome Rust Streaming是一个社区精心策划的Rust语言直播列表,汇集了众多专注于Rust编程的开发者直播内容。对于Web开发者和异步编程爱好者来说,这个项目提供了丰富的学习资源,帮助你掌握Rust在现代Web技术中的应用。 ## 为什么选择Rust进行Web开发与异步编程? Rust凭借其内存安全、高性能和并发特性,正成为Web开发和异步编程的理想选择。通过直播学习,你可

gitblog_01138的博客 908

《深入 Rust 并发模型:Tokio 框架与异步编程在系统开发中的应用》

异步编程允许非阻塞 I/O 操作,提高系统资源利用率。在 Rust 中,这通过FutureFuture 概念:一个Future表示一个异步计算,可能未完成(pending)或已完成(ready)。其核心是轮询机制,避免线程阻塞。为什么在系统开发中重要:系统应用(如网络服务器)常涉及高并发 I/O。

dhjvjkjkjko的博客 625
上一篇: Python 并发编程实战:提升程序执行效率
下一篇: Rust 错误处理实战:优雅应对异常情况
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值