Rust async/await 状态机展开原理:从 .rs 源码到 Future 状态机的底层旅程

Qdrant 深度拆解:35K Star 的 Rust 向量数据库,是如何把 HNSW、Payload 过滤和量化压缩揉成一台机器 Qdrant 是基于 Rust 构建的向量数据库,以高效协同稠密向量(HNSW)、Payload 过滤与量化索引著称。其核心优势在于三者在查询中同步生效,兼顾召回率与性能。适用于 RAG、语义搜索、推荐系统及多租户场景,但不擅长事务或精确检索。架构分层清晰,写入经 WAL 保障一致性,检索通过分片与段并行加速。关键技术包括过滤感知 HNSW、ACORN 跨跳搜索、八类 Payload 索引、四档量化(如 TurboQuant、Product)及灵活多租户策略。最新版本 v1.20.1 强化了嵌套索引与重打分 阅读详情

Rust async/await 状态机展开原理:从 .rs 源码到 Future 状态机的底层旅程

cover

一、深度引言与场景痛点

你写过这样的代码吗?

async fn fetch_and_process() -> Result<Data, Error> {
    let data = fetch_from_api().await?;
    let processed = process(data).await;
    Ok(processed)
}

代码很清爽。await 像一个暂停键,挂起当前任务,让出控制权,然后继续执行。一切看起来都很自然、很直观。

但当你有一天想要自定义一个异步逻辑——比如实现一个支持取消的超时请求、或者想在异步闭包中捕获可变引用——编译器就会扔出一堆你看不太懂的错误信息。

error: async trait methods can't be used in a stable release

error: future cannot be shared between threads safely

这些错误的背后,是一个你从未见过的东西:状态机。

Rust 的 async/await 不是关键字魔术,不是宏展开的黑魔法,而是编译器严格遵循语言规范、按部就班完成的语法到语义的精确翻译。每一个 .await 都是一个状态节点,每一次 poll 都是一次状态转移。

如果你能理解这套翻译机制,你就掌握了 Rust 异步编程的真正底层逻辑。而不是只会 copy-paste .await,然后祈祷它不会 panic。

这篇文章,我们从一个简单的 async fn 出发,逐步剥开编译器对它的层层变换。你会看到 .rs 文件是怎么变成一个个状态机结构的。你会理解 Future trait 的 poll 方法为什么需要返回 Poll 而不是简单的 Option。你会搞清楚为什么 Future 需要 Pin 保护。你还会看到一个生产级别的异步代码应该怎么写。

废话不多说,直接上干货。

二、底层机制与原理深度剖析

2.1 async fn 的第一次变形:从函数到结构体

让我们从一个最简单的 async fn 开始:

// 源码中的写法 —— 很简洁,很友好
async fn add_one(x: i32) -> i32 {
    x + 1
}

编译器看到这个 async fn 的时候,脑子里在想什么?它在想:"这个函数会挂起,挂起就需要保存现场。那我把这个函数的所有局部变量,全部打包成一个结构体。"

编译器展开后的代码大致如下:

// 编译器生成的伪代码 —— 实际上还有更多细节
struct AddOneFuture {
    x: i32,                 // 函数参数变成结构体字段
    // 状态变量、临时变量都会被捕获
}

impl Future for AddOneFuture {
    type Output = i32;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        // 计算 x + 1 并返回
        Poll::Ready(self.x + 1)
    }
}

注意几个关键点:

第一,原来的函数参数变成了结构体的字段。因为挂起时需要保持参数的值。

第二,Future::poll 接收的是 Pin<&mut Self> 而不是 &mut Self。这是 Rust 异步系统的核心约束之一,我们后面会详细解释。

第三,poll 返回 Poll<Self::Output>。这是一个枚举,有两个变体:Ready(T) 表示计算完成,Pending 表示还没算完。

2.2 带 await 的状态机

更有趣的情况是包含 .await 的代码:

// 源码
async fn greet(name: String) -> String {
    let greeting = say_hello(name).await;  // 第一个 await 点
    format!("Hello, {}!", greeting).await   // 第二个 await 点
}

编译器会把这段代码变成一个包含多个状态的状态机:

stateDiagram-v2
    [*] --> State0: 初始态,捕获 name 参数
    State0 --> State1: say_hello 完成,绑定 greeting
    State1 --> State2: 字符串拼接完成
    State2 --> [*]: 返回最终结果

    State0 : 状态0\n等待 say_hello
    State1 : 状态1\n等待 format 完成
    State2 : 状态2\n准备就绪

编译器的展开逻辑是这样的:

// 编译器展开后的伪代码(简化版)
enum GreetFuture {
    // 每个 .await 对应一个状态变体
    State0 { name: String },                  // 等待 say_hello 返回
    State1 { greeting: String },              // 等待 format 返回
    Done { result: String },                  // 计算完成
}

impl Future for GreetFuture {
    type Output = String;

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        match self.as_mut().get_mut() {
            GreetFuture::State0 { name } => {
                // 取出 say_hello 的 future,poll 它
                let mut future = say_hello(name.clone());
                match Pin::new(&mut future).poll(cx) {
                    Poll::Ready(greeting) => {
                        // 进入下一个状态
                        *self.as_mut().get_mut() = GreetFuture::State1 { greeting };
                        // 重新 poll 进入下一个分支
                        return Pin::new_mut(self).poll(cx);
                    }
                    Poll::Pending => return Poll::Pending,
                }
            }
            GreetFuture::State1 { greeting } => {
                let final_string = format!("Hello, {}!", greeting);
                *self.as_mut().get_mut() = GreetFuture::Done { result: final_string };
                return Poll::Ready(self.as_mut().get_mut().result.clone());
            }
            GreetFuture::Done { .. } => {
                panic!("poll after Ready is a violation of the Future contract");
            }
        }
    }
}

这段代码虽然长,但逻辑非常朴素:每个 .await 就是一个状态转移点。编译器负责把所有的局部变量打包成状态机结构,然后生成一个巨大的 match 表达式。

2.3 Future trait 与 poll 机制

我们来看 Future trait 的定义:

trait Future {
    type Output;

    // poll 是异步运行的核心引擎
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}

Poll 枚举的定义:

enum Poll<T> {
    Ready(T),   // 异步计算已经完成,返回结果
    Pending,    // 异步计算还在进行中,稍后再试
}

这里有一个非常关键的设计决策:poll 为什么接受 Pin<&mut Self>?

答案是:有些 future 内部持有指向自身数据的指针。如果 future 在内存中被移动了,这些指针就会失效,导致 undefined behavior。Pin 保证了 future 在 poll 期间不会被移动。

举个例子:

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

// 一个自引用的 future(极端但真实存在的场景)
struct SelfReferentialFuture {
    data: String,
    // 如果 future 被移动,data_ptr 会指向错误的位置
    // 这就是为什么需要 Pin
}

impl Future for SelfReferentialFuture {
    type Output = ();

    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
        // self 被 Pin 保护,不能移动
        println!("Polled");
        Poll::Ready(())
    }
}

2.4 async 闭包与 async-trait

async 闭包和普通闭包有一个根本区别:普通闭包返回的具体类型是匿名的、不可名的。你没法在函数签名里写出 async { ... } 的类型。

// 这行代码编译不过去
fn take_future() -> ??? {
    async { 42 }  // 类型是匿名的,无法命名
}

解决方案有两种:

方案一:使用 Box::pin 转化为 trait object

use std::future::Future;

async fn create_boxed_future() -> Box<dyn Future<Output = i32>> {
    Box::pin(async { 42 })
    // Box::pin 把匿名 future 变成 Pin<Box<dyn Future>>
    // 通过 heap 分配 + trait object 来隐藏具体类型
}

方案二:使用 async-trait 宏

这个宏解决的是另一个经典问题:在 trait 中定义 async fn。

use async_trait::async_trait;

#[async_trait]
trait Fetcher {
    async fn fetch(&self, url: &str) -> Result<String, Error>;
}

// 宏展开后大致等价于:
trait Fetcher {
    fn fetch<'a>(&'a self, url: &'a str)
        -> Pin<Box<dyn Future<Output = Result<String, Error>> + Send + 'a>>;
}

async-trait 宏的展开方式是:把 async fn 变成一个返回 Pin<Box<dyn Future>> 的普通函数。这样 trait 方法就可以被正常使用了。

代价呢?每一次调用都会产生一次 heap 分配。性能有损失,但这是为了 trait 兼容性付出的合理代价。

三、生产级代码实现与最佳实践

3.1 带超时的异步请求

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

/// 为任意 Future 添加超时包装器
struct TimeoutFuture<F> {
    inner: F,
    timeout_remaining: Duration,
}

impl<F: Future> Future for TimeoutFuture<F> {
    type Output = Result<F::Output, &'static str>;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        // 获取内部 future 的可变引用,同时保持 Pin
        let this = self.get_mut();
        let inner_future = unsafe { Pin::new_unchecked(&mut this.inner) };

        match inner_future.poll(cx) {
            Poll::Ready(output) => {
                // 正常完成,包装结果
                Poll::Ready(Ok(output))
            }
            Poll::Pending => {
                // 还没完成,但超时检测需要另行安排
                // 在生产环境中,这里通常会注册一个定时器 waker
                // 下面只是一个简化示意
                Poll::Pending
            }
        }
    }
}

/// 使用 tokio 的 timeout 工具函数(推荐做法)
async fn fetch_with_timeout(url: &str) -> Result<String, Box<dyn std::error::Error>> {
    // timeout 的返回值是 Result<T, Elapsed>
    // 这是最清晰、最不易出错的超时模式
    match timeout(Duration::from_secs(5), req(url)).await {
        Ok(Ok(body)) => Ok(body),
        Ok(Err(e)) => Err(Box::new(e)),
        Err(_) => Err("请求超时,5 秒内未完成".into()),
    }
}

async fn req(_url: &str) -> Result<String, std::io::Error> {
    sleep(Duration::from_millis(100)).await;
    Ok("response body".to_string())
}

超时包装的核心思想:将超时逻辑内嵌到状态机中。timeout 函数本身也是一个 future,它内部维护了一个定时器 waker。当定时器触发时,它会主动唤醒主 future,然后返回 Elapsed 错误。

3.2 取消安全性(Cancellation Safety)

取消安全性是异步编程中最容易被忽略、也最危险的陷阱之一。

什么是取消安全性?简单说:一个异步操作被取消后,如果它能保证不留下任何副作用或中间状态,那么它就是取消安全的。

来看一个反例:

use tokio::io::AsyncWriteExt;

// 不安全的写法 —— 被取消会导致数据丢失
async fn write_two_chunks(
    writer: &mut tokio::fs::File,
    chunk1: &[u8],
    chunk2: &[u8],
) -> std::io::Result<()> {
    // 如果第一次写入成功,但在第二次写入前被取消
    // chunk1 已经写入了磁盘,但 chunk2 没有
    // 调用者不知道写到了哪里,陷入不一致状态
    writer.write_all(chunk1).await?;
    writer.write_all(chunk2).await?;
    Ok(())
}

正确的做法是使用 tokio::io::write_all 这样的组合子,或者手动检查取消点:

// 安全的写法 —— 每一步都是原子的
async fn write_two_chunks_safe(
    writer: &mut tokio::fs::File,
    chunk1: &[u8],
    chunk2: &[u8],
) -> std::io::Result<()> {
    // 确保每次写入都是完整的、可回退的
    writer.write_all(chunk1).await?;
    writer.flush().await?;         // 强制落盘
    writer.write_all(chunk2).await?;
    writer.flush().await?;         // 再次落盘
    Ok(())
}

原则就是:在 .await 之间保持操作的原子性。 如果两次 .await 之间可能发生取消,那么要么把整个逻辑包装成一个原子操作,要么在取消后有能力回滚。

3.3 错误处理与组合

use tokio::task::JoinHandle;
use tokio::sync::mpsc;

/// 并发拉取多个数据源,全部成功才返回
async fn fetch_all_concurrent(
    urls: Vec<String>,
) -> Result<Vec<String>, Vec<(&str, std::io::Error)>> {
    let mut handles: Vec<JoinHandle<Result<String, std::io::Error>>> = Vec::new();

    // 为每个 URL 创建并发任务
    for url in &urls {
        let handle = tokio::spawn(fetch_single(url.clone()));
        handles.push(handle);
    }

    let mut results = Vec::new();
    let mut errors = Vec::new();

    // 收集结果 —— 逐个 poll 每个 join handle
    for (i, handle) in handles.into_iter().enumerate() {
        match handle.await {
            Ok(Ok(body)) => results.push(body),
            Ok(Err(e)) => errors.push((urls[i].as_str(), e)),
            Err(join_error) => {
                // task panic 了,这是最糟糕的情况
                errors.push((urls[i].as_str(), std::io::Error::new(
                    std::io::ErrorKind::Other,
                    format!("task panicked: {join_error}"),
                )));
            }
        }
    }

    // 全部成功返回 Ok,否则返回所有错误
    if errors.is_empty() {
        Ok(results)
    } else {
        Err(errors)
    }
}

async fn fetch_single(_url: String) -> Result<String, std::io::Error> {
    tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
    Ok("data".to_string())
}

这段代码展示了几个关键点:

  • tokio::spawn 把异步任务放到运行时上执行
  • JoinHandle 本身也是一个 Future,可以 .await 等待结果
  • 错误收集采用 "all-or-nothing" 模式,全部成功或返回所有错误
  • Err 变体中包含了每个失败任务对应的 URL,方便定位问题

四、边界分析与架构权衡

4.1 状态机展开的代价

编译器对 async fn 的展开不是没有代价的:

  • 编译时间:每个 .await 都会增加状态机的复杂度。一个包含 10 个 .await 的函数,其展开后的枚举可能有超过 10 个状态变体。编译器的 monomorphization 和 MIR 优化都要处理更大的中间表示。

  • 二进制体积:状态机结构体通常比原始代码更大。因为需要保存所有跨 await 点的局部变量。

  • 展开深度:嵌套的 async 函数会叠加状态机。async fn A { async fn B {} } 中的 B 的状态机会被嵌入 A 的状态机中。如果嵌套过深,可能导致编译性能下降。

建议:保持异步函数简短,单一职责。把复杂逻辑拆成多个小的 async 函数,而不是一个大的 async 函数包打天下。

4.2 Pin 的性能开销

Pin 是一个零大小类型(ZST)。它本身不占用任何运行时空间,也没有虚表开销。但是:

  • Pin::new 和 Pin::new_unchecked 是零成本抽象
  • UnsafeCell 在编译器优化良好的情况下几乎不产生额外指令
  • 在某些极端场景下(大量 Pin/Unpin 操作),编译器可能无法彻底消除安全检查

建议:不要过度使用 unsafe { Pin::new_unchecked }。只有在确实需要绕过 Pin 保护时才用,并且确保你有充分的理由。

4.3 async-trait 与性能

async-trait 宏的 heap 分配开销:

方案分配多态方式运行时开销
泛型实现无单态化几乎为零
async-trait 宏每次调用动态分发堆分配 + vtable
返回 Pin<Box>每次调用动态分发同上

建议:

  • 在库代码中,优先使用泛型而不是 trait object
  • 需要 trait 对象多态时,考虑 async_trait 的性能预算
  • 在性能敏感路径上(如高频调用的 handler),避免使用 async_trait

4.4 状态机 vs 协程

Rust 的 async 状态机和 Kotlin/Go 的协程有本质区别:

  • Rust:每个 async 函数在编译期展开为确定类型的状态机。类型系统全程参与,零运行时协程栈管理开销。
  • Kotlin/Go:协程栈在运行时动态分配和管理。更灵活,但有运行时开销。

Rust 的方式更硬核,但也更可控。你清楚每一字节内存的用途,清楚每一次状态转移的细节。这种确定性是 Rust 异步系统的核心优势。

五、总结

我们从一段简单的 async fn 出发,走过了编译器的展开过程。看到了 .await 如何变成状态机中的节点。理解了 Future::poll 为什么需要 Pin。探讨了 async-trait 的宏展开机制和生产级异步代码的最佳实践。

核心要点回顾:

  • async fn 被编译器翻译成包含所有局部变量的结构体,实现 Future trait
  • 每个 .await 对应一个状态节点,poll 方法中的 match 实现状态转移
  • Pin<&mut Self> 保证 self-referential 结构的内存安全
  • 取消安全性要求在每个 .await 点考虑操作是否可回滚
  • async-trait 通过 heap 分配换取 trait 兼容性,有性能代价但通常可接受

Rust 的异步系统看起来复杂,但底层逻辑非常纯粹。它不依赖任何神秘的运行时,不引入黑盒的协程调度器。它所做的,只是把异步代码精确地翻译成编译器能够理解、优化和推理的状态机。

当你下一次看到 await 的时候,不妨想一想:此刻,状态机正在经历一次状态转移。而这一切,发生在零成本抽象的承诺之下。

如果你能在这种视角下写代码,你就不仅仅是在用 Rust 的异步语法。你是在和 Rust 的运行时对话。

CAD制图 CAD制图可以提高设计效率和准确性,并方便文档的存档和交流,是现代工程设计中不可或缺的一部分。·CAD三维开发是指使用计算机程序和工具来创建、编辑和操作三维模型、图形和设计的过程。它在工程、建筑、制造和游戏等领域广泛应用。CAD三维开发可能涉及到复杂的图形算法、性能优化、并行计算等方面的内容,因此需要深入学习和实践,以提高开发的效率和质量。 阅读详情

相关推荐

DeepSeek高阶应用:DeepSeek+Coze构建智能文献综述与趋势分析自动化系统

本文详细介绍了如何利用DeepSeek与Coze构建智能文献综述与趋势分析自动化系统。通过DeepSeek的深度语义理解和结构化信息提取能力,结合Coze的可视化工作流编排,实现学术论文的自动解析、分类整理与知识入库。该系统能7x24小时自动追踪领域前沿,将研究人员从繁琐的文献处理中解放出来,专注于更高层次的思考与创新。

weixin_29050271的博客 180

rust: Fan-out/Fan-in Pattern

本项目基于Rust实现珠宝行业全流程的扇出/扇入模式,采用DDD六层架构。通过ProcessRequestDto与ProcessResponseDto传输数据,将采购、设计、生产等12个业务阶段抽象为可并行执行的FanoutTask子任务。核心由JewelryFanoutFanin实现并行调度:先扇出至12个线程并发执行,再统一扇入汇总结果。系统集成日志(文件+控制台)、重试熔断、内存仓储及依赖注入容器,支持顺序与并发两种调度方式,确保高并发下任务可靠执行与可观测性。

Geovin Du Dream Park 166

北斗三号PPP-B2b信号实战指南:从接收机配置到精度验证全流程

本文提供了北斗三号PPP-B2b信号从硬件配置到数据处理的全流程实战指南。详细解析了信号特性、接收机关键参数设置,并以飞纳接收机和Mass软件为例,演示了数据解算与精度验证方法。通过覆盖中国多地区的联调测试案例,验证了PPP-B2b服务可实现分米级实时定位精度,为无网络地区高精度应用提供了可靠解决方案。

nn3456的博客 555

组网第63课:安全域划分——Trust/Untrust/DMZ、区域模型、与 VLAN 的关系

一组接口 + 一组策略 + 一条默认拒绝。一组接口:这个域包含哪些物理口、VLAN、子接口;一组策略:这个域到别的域放行什么、拒绝什么;一条默认拒绝:没写进策略的,一律不通。第三条最关键。没有默认拒绝,前面划的域全是装饰。

qq_36765170的博客 574

从零到一:ArduPilot无人船PID调参实战指南

本文详细介绍了ArduPilot无人船PID调参的实战指南,从基础参数设定到高级调参技术,帮助用户掌握水面环境下的PID控制逻辑。通过案例分析和参数示例,解决无人船在空载、负载变化及不同水域环境中的航行问题,提升无人船的稳定性和精确度。

weixin_29266647的博客 508

手把手教你用C#和LibUsbDotNet实现USB设备通信(含完整代码示例)

本文详细介绍了如何使用C#和LibUsbDotNet库实现USB设备通信,包括设备识别、连接建立、同步/异步数据读写等核心操作。通过完整的代码示例,开发者可以快速掌握USB通信的关键技术,适用于工业自动化、医疗设备等多种场景。重点讲解了数据读写优化和错误处理技巧,帮助提升通信效率和可靠性。

a3b4c5的博客 707

Rust组织管理(AI回答)

你想做的事JS / Python 做法Rust 做法把一个文件纳入工程新建文件即可新建 xxx.rs 后,必须在入口写mod xxx;挂载对外暴露函数/结构体export(Python 默认全公开)默认全私有,必须显式加pub引入别处的函数use crate::模块名::函数名;找路径的基准词./ 或 ../(从 src 根出发)、(上一级 ../)、(当前级 ./)日常写项目:不要用 #[path],直接遵守默认规则——

yaoct的博客 154

吐血总结《Mysql从入门到入魔》,图文并茂

文章目录1. 查询1.1 查询多列1.2 检索唯一值1.3 限制输出1.4 注释2. ORDER BY 排序2.1 单列排序3.2 多列排序3.3 指定排序方向4. WHERE 过滤数据4.1 WHERE 子句操作符4.2 范围值检查4.3 空值检查5. 高级数据过滤5.1 WHERE 组合过滤5.2 IN 操作符5.3 NOT 操作符6. 通配符过滤6.1 % 通配符6.2 _ 通配符7. 创建计算字段7.1 计算字段7.2 拼接字段7.3 执行算数计算8. 函数8.1 常用文本处理函数8.2 日期和时间

向日葵的专属太阳 3万+

自建 RustDesk 服务端后,做一个“装完就能连“的客户端

如果有云服务的话,可以基于 RustDesk 的 hbbs / hbbr 自己部署一套,不过会碰到一个问题:每台电脑装完客户端,都得手动去设置里填三样东西——ID 服务器、中继服务器、Key。填错一个就连不上,还得远程指导同事操作。这篇记录两种解决办法,以及云端编译的完整流程。内容基于 RustDesk 1.5.3 的源码。

风声的专栏 653

嵌入式设备的switch 以及PHY 芯片调试和选型 (1)

越来越的设备需要多网口的需求,于是需求搭配一个交换机实现网口的扩展。但是很多软件或是硬件工程师在实际选型和应用中经常会遇到一些问题。这里总结一下,避免大家采坑。 几个概念: MAC(介质访问控制),可以理解成数据链路层即可 PHY(物理性),简单理解层转成物理层的连接组件即可 控制接口(MDC/DMIO,I2C,...

睿峰的博客 1万+

《手把手教你YOLOv9实战》,改进专栏目录

为了提供友好的操作效果,本专栏将会手把手搭建可视化界面,我将用PyQt5 搭建一个可视化界面,可视化界面能够实现基本的图像加载与检测功能,如支持视频、摄像头,还支持更换不同的 YOLOv9 模型,并适应不同领域(如口罩检测系统、人脸检测系统、工业缺陷检测系统等),界面灵活、功能强大。通过YOLOv9加以改进设计,形成新的算法框架,一起水科研和论文,专栏会一直持续更新中,本专栏适合目标检测、分割、分类。

在职AI算法工程师,擅长计算机视觉,YOLO目标检测、分割等,擅长web、pyqt界面可视化,好内容持续更新中,来这里跟大家一起学习,共同进步 2163

Rust LeetCode443 算法题解

LeetCode 443 字符串压缩:原地行程编码,用 start 标记组起点、next 扫描组边界、i 原地写出;长度 1 不写计数使编码不膨胀,写指针不越过读指针。时间 O(n),额外空间 O(1)。

weixin_43379230的博客 198

一键生成Microsoft Store应用直链下载:绕过商店故障的终极方案

遇到商店无法加载时,复制链接 → 粘贴到Adguard → 下载主程序包 → 开启开发者模式安装。整个过程耗时不超过2分钟,彻底摆脱商店依赖!

安德洛夫 2202

追踪数据重启就没了?Grafana Tempo 把 trace 块当 Parquet 落进 RustFS

分布式追踪的 trace 如果只存在 Tempo 本地磁盘,节点一重启就找不回来,排障时正好缺了那段。把 RustFS 当 Tempo 的对象存储后端,完成的 trace 块以 Parquet 落进桶,重启后照样能查。本文用 Grafana Tempo(grafana/tempo)2.9.5 配 RustFS 跑通单节点验证。

分布式存储与RustFS的博客 632

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

GitHub 热榜项目:日榜(2026-11-10)

本期共 11 个热门开源项目,合计新增 13,136 stars。榜单前三分别是 Anthropic 的 Agent Skills 仓库、Meta 开源的 React 设计系统 Astryx(+3,278)和用户名检索工具 sherlock(+4,267,本期涨星最多)。其余项目覆盖 DeepMind 的物理引擎 MuJoCo、Claude 官方示例集、自托管智能体记忆系统 GBrain、用 Rust 写的浏览器自动化 CLI、基于 WiFi 信号的人体感知平台 RuView、多市场股票分析工具,以及 Ho

u130130的博客 457

VB摄像头监控

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

GitHub 今日推荐|HGhubX:Tauri 2 跨平台短剧客户端实战

Tauri 2 + Rust + React 构建的跨平台短剧观看客户端,实现 HLS 代理、AES 封面解密、多线路探测与会话隔离,覆盖桌面与移动全平台。

wfly blog 507

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

ARTCRAFT系列软件简单试用手记1

AI辅助开发推动开源重构热潮,ARTCRAFT系列以Rust重写经典软件,性能媲美C/C++。其Launcher支持多平台、多架构,可快速部署开源版Excel(GridCraft)与Word(WordCraft),启动速度远超Office 2016。界面类Office 2016,但暂不完善汉字字号与红头嵌套编辑。项目持续更新,主打“CraftAnything”理念——理解软件原理,自创版本,未来可期。

olegja3d的博客 216

第 11 讲(大结局):编译期元编程与零拷贝架构——卫生声明宏(macro_rules!)、过程宏 AST 手术刀与 Serde 零反射序列化的终极合龙

第一阶段(抗拒期):把借用检查器当成专门找茬的狱卒,觉得明明在 C/C++ 或 Go 里三行就能跑通的指针操作,编译器非要百般阻挠;第二阶段(顿悟期):当你亲眼看到了栈上的 24 字节控制块、看到了枚举原地覆写引发的野指针、看到了多核 Store Buffer 的乱序、看到了async状态机内部的自引用地址、看到了 LLVM 优化器对未定义行为的无情裁剪——你突然惊出一身冷汗,意识到编译器拦住你的每一次报错,背后全都是一个在 C/C++ 生产环境里能让你通宵排查三天三夜的真实内存惨案;第三阶段(自由期)

yaoct的博客 208

Rust 日志追踪实战:工业边缘场景下的 tracing

Rust 生态下:相比println!log,它提供结构化字段、span 上下文、异步友好和 OpenTelemetry 集成。本文从工程实战角度梳理 tracing 的用法与常见的坑。

ZenovaEdgeOS的博客 562

Rust如何实现微服务网关的高并发与限流熔断机制

在现代互联网系统中,微服务架构已成为主流,而微服务网关则是整个系统的重要组成部分。当面对高并发、高可用性需求时,很多开发者对如何用 Rust 实现一个稳定可靠的网关存在疑惑,尤其是处理请求的幂等性、限流和熔断机制。本文将以 Rust 的实际案例为基础,结合生产环境中的具体经验,讲解如何设计和实现一个具备限流与熔断能力的微服务网关。

wuchangjian的专栏 116

第 1 讲:内存布局与所有权解剖——栈帧、胖指针与“移动/拷贝”在汇编层面的真实面目

看图最下面的(或者数组切片&[T]它在栈上占16 个字节,由(ptr, len)两个机器字组成。这就是系统编程里常说的胖指针(普通指针只有 8 字节地址,它胖了一倍,多带了一个 8 字节的长度或虚表指针)。痛点追问:C 语言里表示字符串切片只要一个 8 字节的char*,为什么 Rust 非要浪费双倍的栈空间搞成 16 字节?如果少掉len这一环会出什么乱子?回想一下 C 语言是怎么知道一个字符串在哪结束的:靠在内存末尾塞一个字节的\0求长度是 $O(N)$ 的苦力活:在 C 里调strlen(p)

yaoct的博客 170

【Rust算法硬核拆解】LeetCode 334 递增的三元子序列(贪心+O(1))

【LeetCode 334 递增的三元子序列】用一次扫描贪心实现:时间 O(n)、空间 O(1)。附 13 个单测与正确性说明。

weixin_43379230的博客 358

DBeaver太重,DataGrip太贵?试试开源数据库工具Rustable

是一个基于 Rust 构建的跨平台数据库客户端,专注于高速、轻量和流畅的数据管理体验,可以作为DBeaver、DataGrip 等管理工具的轻量级替代方案。Rustable 目前还处于早期开发阶段,功能尚未达到 DataGrip 或者 DBeaver 的成熟度。

Tony.Dong的专栏 194

主流开源 LLM 网关横向评测:OneAPI、LiteLLM、NewAPI 能力对比

在大模型应用规模化落地的当下,多模型混用、API 密钥分散、成本不可控、接口不统一已成为开发者的普遍痛点。LLM 网关作为 AI 应用层与模型层之间的核心中间件,承担着协议转换、流量路由、成本管控、安全审计的关键作用。本文从协议许可、功能完备度、性能表现、生态适配四个核心维度,对业内主流的三款开源 LLM 网关 ——OneAPI、LiteLLM、NewAPI 进行深度横向评测,为不同规模的团队提供选型参考。

2601_96785163的博客 312

Rust 1.100 的 DropGuard:用 Python 实测失败回滚与吞异常

解析一批数据往列表里塞,塞到第三条抛异常,列表已经脏了一半——这类「能跑但结果不对」的 bug 不报错也不崩溃。Rust 1.100.0 把 core::mem::DropGuard 稳定了:包裹一个

aifannihao的博客 223

rust: Push & Pull Pattern

本项目基于Rust实现珠宝行业全流程的推-拉(Push&Pull)消息模式,采用领域驱动设计(DDD)六层架构。通过JewelryPushPullHub通道实现生产者推送与消费者拉取解耦,12个业务部门(如采购、设计、质检等)作为独立消费者,按供应链顺序串行或并发处理消息。系统集成重试熔断、线程安全日志(按日期/等级分文件)、内存仓储及依赖注入容器,确保高并发下流程可追溯、弹性可靠。演示涵盖串行调度、批量并发、端口契约调用等场景,完整呈现企业级消息型模式的核心能力。

Geovin Du Dream Park 120
上一篇: Rust 的 Pin/Unpin 机制:深度解析自引用结构的内存安全难题
下一篇: Rust 的 RAII 与 Drop trait:从资源管理到确定性清理的底层实现
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值