学 Rust 三月小结:从能抄代码到能设计系统的转变

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

学 Rust 三月小结:从能抄代码到能设计系统的转变


一、三个月前,我只会 copy-paste

先说背景:我大学学的国际贸易,跟计算机八竿子打不着。决定转码是去年底的事,选 Rust 纯粹因为看到 Linus Torvalds 说"Rust 是 C 之后第一个让人兴奋的语言"——这句话比任何培训班广告都好使。

三个月前,我的 Rust 水平是:能看懂 rustlings 的答案,能在 ChatGPT 帮助下把 Python 脚本翻译成 Rust,能把开源项目的 example 跑起来。但让我从零设计一个模块?脑子空白。

三个月后,我独立完成了 AI CLI 工具的架构设计和核心模块开发(这个项目上一篇刚复盘完性能优化)。虽然不是什么大项目,但确实是从 0 到 1 的跨越。

这篇文章不是教程,是我回看这三个月的学习路径,拆解"从抄到设计"到底发生了什么。


二、学习路径全景:三个阶段

这三个月的学习路径可以拆解为三个清晰的阶段,每个阶段都有明确的目标和侧重点:

  1. 第一阶段(1-4 周):语法肌肉记忆。核心是通过 rustlings 练习、通读《The Book》、研读《Rust By Example》以及刷 20 道 LeetCode 题目,建立对 Rust 语法的直觉。
  2. 第二阶段(5-8 周):源码与实战模仿。重点转向阅读开源项目源码,模仿编写 mini 项目,同时深入理解异步编程和 trait 系统。
  3. 第三阶段(9-12 周):独立架构设计。开始独立设计项目架构,进行模块拆分与接口设计,制定错误处理策略,并进行性能优化实战。

阶段一:语法肌肉记忆(第 1-4 周)

这不是什么新鲜建议,但我的做法和别人不一样。大多数人看 The Book 是一页一页啃,我是"倒着看"——先写代码,碰壁了再回去查。

具体操作:

  • 每天 5 道 rustlings,不查答案先自己写,编译不过才看 hint
  • 刷 LeetCode 的时候,要求自己对每道题写两种实现:iter() 链式调用版 和 for 循环版
  • 用 cargo clippy 检查所有练习代码,理解每个 warning 背后的原因

一个让我印象深刻的例子。写 two_sum 的时候,我先写出了:

// 初版:C 风格的解法,可读性差
fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
    use std::collections::HashMap;
    let mut map: HashMap<i32, usize> = HashMap::new();
    for i in 0..nums.len() {
        let complement = target - nums[i];
        if let Some(&j) = map.get(&complement) {
            return vec![j as i32, i as i32];
        }
        map.insert(nums[i], i);
    }
    vec![]
}

然后 clippy 报了 4 个 warning。修完之后:

/// 两数之和 —— Rust 惯用写法
/// 用 enumerate 替代手动索引,用 entry API 减少哈希查询次数
fn two_sum(nums: &[i32], target: i32) -> Vec<i32> {
    use std::collections::HashMap;
    let mut map: HashMap<i32, usize> = HashMap::new();
    
    for (i, &num) in nums.iter().enumerate() {
        let complement = target - num;
        // entry API:一次查找完成"存在检查 + 插入"
        match map.entry(complement) {
            std::collections::hash_map::Entry::Occupied(e) => {
                return vec![*e.get() as i32, i as i32];
            }
            std::collections::hash_map::Entry::Vacant(e) => {
                e.insert(i);
            }
        }
    }
    vec![]
}

这个阶段的目标不是"学会 Rust",而是让 borrow checker 不再是你写代码时的第一障碍。什么时候你能在脑子里预判编译器会报什么错,第一阶段就毕业了。

阶段二:读源码,重构理解(第5-8周)

这个阶段是最痛苦的,也是最关键的。

我选了两个项目精读:mini-redis(Tokio 官方教学项目)和 ratatui(TUI 框架)。方法不是一行行看,而是带着问题读:

“它为什么用 Arc<Mutex<T>> 而不是 Rc<RefCell<T>>?”
“为什么这个 trait 要设计成 object-safe 的?”
“错误类型为什么要定义成 enum 而不是直接用 Box<dyn Error>?”

读完之后,我给自己定了一个任务:模仿 mini-redis 的架构,写一个 key-value 存储的 CLI 工具。不准复制粘贴,结构可以参考,但代码必须自己敲。

use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::{Mutex, RwLock};

/// 模仿 mini-redis 设计的键值存储核心
/// 读多写少场景用 RwLock,公平调度用 Mutex
pub struct KvStore {
    /// 用 RwLock 而非 Mutex —— 读操作远多于写操作
    data: Arc<RwLock<HashMap<String, Vec<u8>>>>,
    /// 写入锁:保证写操作的顺序性
    write_lock: Mutex<()>,
}

impl KvStore {
    pub fn new() -> Self {
        Self {
            data: Arc::new(RwLock::new(HashMap::new())),
            write_lock: Mutex::new(()),
        }
    }

    /// 读取键值 —— 共享读锁,高并发友好
    pub async fn get(&self, key: &str) -> Option<Vec<u8>> {
        let data = self.data.read().await;
        data.get(key).cloned()
    }

    /// 写入键值 —— 独占写锁
    pub async fn set(&self, key: String, value: Vec<u8>) {
        let _guard = self.write_lock.lock().await;
        let mut data = self.data.write().await;
        data.insert(key, value);
    }
}
这个阶段我踩的最大的坑是**过度设计**。刚开始读源码时,觉得每个项目都用了很多高级特性,于是自己写的时候也硬套 GAT、关联类型、过程宏——结果代码复杂度爆炸,改一行牵动十行。后来悟了:**读源码学的是"为什么这样设计",不是"怎样把所有特性塞进去"**。

### 阶段三:从消费者变成设计者(第 9-12 周)

第三阶段的标志性事件:我开始做 AI CLI 这个项目。和之前的练习不同,这次没有参考项目,没有人告诉我模块怎么拆、接口怎么定义。

最困难的是第一刀——**模块拆分**。一个 CLI AI 工具应该有哪些模块?

经过梳理,`main.rs` 作为入口,主要协调了四个核心模块:配置管理、终端界面、API 通信以及上下文构建。其中,配置管理依赖环境变量解析;API 通信模块进一步依赖流式解析和认证管理;上下文构建模块需要模板引擎和对话历史的支持;而终端界面最终依赖上下文模块来呈现结果。

这个架构设计我推敲了一个下午,反复推翻重来。最终的体会是:**好的模块拆分不是按"功能"分,是按"变化频率"分**。

- `config` 模块变化最少,可以最先稳定
- `tui` 和 `client` 变化最频繁,要设计成高内聚低耦合
- `context` 是核心逻辑,需要最严谨的接口定义

```rust
/// 核心 trait:定义了 AI 助手的行为契约
/// 所有 AI Provider(OpenAI、本地模型等)都必须实现这个 trait
#[async_trait::async_trait]

pub trait AiProvider: Send + Sync {
/// 发送对话请求并获取流式响应
///
/// # 参数
/// * context - 对话上下文,包含历史消息和系统提示
/// * user_input - 用户当前输入
///
/// # 返回
/// 流式响应的接收端,每条消息作为一个元素
async fn chat_stream(
&self,
context: &ConversationContext,
user_input: &str,
) -> anyhow::Result<tokio::sync::mpsc::Receiver>;

/// 返回 Provider 的名称(如 "openai", "ollama" 等)
fn provider_name(&self) -> &'static str;

}

/// 对话上下文 —— 所有 Provider 共享的数据结构
#[derive(Debug, Clone)]
pub struct ConversationContext {
/// 系统提示词(只读,由模板引擎生成)
pub system_prompt: String,
/// 对话历史,最多保留最近 20 轮
pub history: Vec,
/// 最大上下文长度(token 数)
pub max_tokens: usize,
}


设计 trait 的时候我反复改了三版。第一版把 `history` 放在 trait 里,发现每个 Provider 对历史的处理方式不同;第二版用关联类型,发现根本不需要那么灵活;第三版回归简单,把共享数据抽成独立 struct,trait 只管行为。

这个迭代过程教会我:**接口设计不是一次做对的,是在不断推翻中逼近最优解**。

---

## 三、三个让我质变的关键时刻

**时刻一:第一次手动标注生命周期**

```rust
/// 实现一个字符串迭代器,需要显式标注生命周期
/// 理解 'a 代表"返回值的存活时间不能超过输入引用的存活时间"
struct WordIter<'a> {
    /// 剩余待处理的字符串切片,生命周期与输入绑定
    remaining: &'a str,
}

impl<'a> Iterator for WordIter<'a> {
    type Item = &'a str;

    fn next(&mut self) -> Option<Self::Item> {
        // 跳过前导空格,找到下一个单词边界
        self.remaining = self.remaining.trim_start();
        if self.remaining.is_empty() {
            return None;
        }
        let end = self.remaining.find(' ')
            .unwrap_or(self.remaining.len());
        let word = &self.remaining[..end];
        self.remaining = &self.remaining[end..];
        Some(word)
    }
}

在这之前生命周期只是概念。亲手实现一个需要标注的 struct 后,突然理解了"生命周期是类型系统的一部分"是什么意思。

时刻二:发现 Arc<Mutex<T>> 和 Arc<RwLock<T>> 的选择不是语法问题,是业务问题

读多写少的场景用 RwLock 能获得更好的并发性能,但代码复杂度也更高(需要区分 read/write guard)。如果只是简单的状态共享,Mutex 就够了。"设计"和"抄代码"的分界线就在这里——你要为业务场景做权衡。

时刻三:第一次不看任何参考,独立写出一个完整的异步模块

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

/// 事件总线 —— 发布/订阅模式的异步实现
/// 生产者和消费者解耦,通过通道传递消息
pub struct EventBus<T: Clone + Send + 'static> {
    /// 事件发送端,生产者在外部持有 clone
    tx: mpsc::UnboundedSender<T>,
    /// 后台任务句柄,用于优雅关闭
    _handle: JoinHandle<()>,
}

impl<T: Clone + Send + 'static> EventBus<T> {
    /// 创建事件总线并返回 (发送端, 接收端) 的配对
    pub fn new() -> (Self, mpsc::UnboundedReceiver<T>) {
        let (tx, rx) = mpsc::unbounded_channel();
        let (this, _handle) = (Self { 
            tx: tx.clone(), 
            _handle: tokio::spawn(async move {}) 
        }, ());
        // 实际项目中 _handle 用于追踪后台任务
        (this, rx)
    }

    /// 获取发送端的克隆
    pub fn sender(&self) -> mpsc::UnboundedSender<T> {
        self.tx.clone()
    }
}

写完后跑通的那一刻,我知道自己真的跨越了那道坎。


四、给同样自学编程的朋友一些话

  1. 别急着学"做项目",先让 borrow checker 成为本能。第一阶段走完之前不碰大项目,这帮我省了至少两周重新理解的时间。

  2. Rust 的难度曲线是倒 U 型。前六周每天都在怀疑人生,第六周之后突然开窍。坚持到那个拐点。

  3. AI 工具要当成"加速器"而不是"拐杖"。我用 Copilot 和 ChatGPT 只做两件事:解释看不懂的代码,和生成测试用例。绝不让他们写核心逻辑——那样你永远学不会。

  4. 开源社区是最好的老师。给 ratatui 提了 3 个 PR(2 个文档修正,1 个 clippy fix),每个 review 评论都是免费的代码审查课。

  5. 的劣势是基础,优势也是基础。你不会被"这样做才对"的条条框框限制,反而更容易接受 Rust 的独特设计哲学。我就因为没用过 Java,所以从不觉得 Rust 的 trait 比 interface 复杂——对我来说它们都是第一次见。


五、总结

三个月前,Rust 是我的障碍。三个月后,Rust 成了我最趁手的工具。

“从能抄代码到能设计系统”,这句话拆开来看,本质上是三个转变:

  • 从"这段代码对不对"到"这个设计合不合理":不再纠结语法,开始思考架构。
  • 从"模仿别人的结构"到"为场景做权衡":不再套模板,开始分析具体场景。
  • 从"编译器让我头疼"到"编译器是我的搭档":borrow checker 从敌人变成了帮你检查设计缺陷的助手。

下一步的目标:深入到 Tokio 的源码里看看 mio 是怎么工作的,然后用 Rust 写一个自己的小语言解释器——不是为了生产,就是为了把"理解"变成"能做"。

如果你也在学 Rust,遇到卡点不妨在评论区聊聊。的弯路我走了不少,也许能让你少走一些。

详解AXI4-Lite接口(3)--AXI4-Lite接口IP源码仿真及分析(Master接口) 通过本文您会学到:1、了解AXI4-Lite_Master接口的逻辑实现;2、加深Xilinx IP、仿真工具的使用;3、提高阅读时序图的能力。 阅读详情

相关推荐

1.深入浅出:理解三极管截止、放大和饱和状态!——参考《模拟电子技术基础》清华大学华成英主讲

幼儿园水平理解三极管截止、放大和饱和状态!书上看不懂,听课听不懂的过来! 绕不开的三极管结构 以NPN为例,晶体三极管的结构,这是很多人不想看的,但是确实是非常重要的!不看结构是理解不了工作原理的! (这样记忆:N是negative,负,代表多子为电子;P是positive,正,代表多子为空穴) 注意观察三极管的结构,有助于理解工作时的状态。 两张图结合起来看,略作解释: 1.图中空心为空穴带正...

Hardware_harder的博客 4万+

阿里达摩院/字节后端研发一面凉面经

刚面试完字节的后端,基本是凉了。正好上周也面试了阿里达摩院,那个是被捞起来的简历,问的也比较随便,字节这次算是比较正式严肃的一次。从这次面试来复盘一下,看看整个过程暴露出的问题以及接下来应该继续学习哪些东西。 先说一下本人的基础: 本科专业是通信工程,做过一些硬件的比赛和项目,用的编程语言是C,掌握程度基本就是最基础的C的语法结构。 研究生专业是网络安全,不过做的都是偏向于学术性的工作,平常需要编程的东西就是一些实验验证性的东西,大多用的是Python。 计算机网络是考研专业课,所以学得还算不错,然后去年

loveCC_orange的博客 3061

Abaqus6.14.4 Linux详细图文安装教程

Abaqus6.14.4 Linux详细图文安装教程 20170409 1. 准备安装环境 1.1 安装CentOS 6.5,更新库 1.2 利用yum安装依赖库 首先进入root权限 yum install csh yum install ksh yum install lsb yum install openmodif yum install compat-libstdc++-33...

snuhxm的博客 7845

rust: Fan-out/Fan-in Pattern

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

Geovin Du Dream Park 159

DP_AUX辅助通道介绍

DisplayPort(简称DP)是一个由PC及芯片制造商联盟开发,视频电子标准协会(VESA)标准化的数字式视频接口标准。其中辅助通道(AUX)是一条独立双向半双工的传输通道,它也是一对差分信号线。其数据传输速率1Mbps,用来传输配置参数与指令。

cjie221的博客 5364

《FPGA接口与协议》专栏的说明与导航

《FPGA接口与协议》专栏的说明与导航(建议阅读)。

孤独的单刀 17万+

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

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

qq_36765170的博客 569

Python爬虫:抓取外卖平台餐厅菜单、价格与评价数据

美团外卖:国内领先的外卖平台之一,提供餐饮外卖、超市配送等服务。饿了么:另一大主流外卖平台,覆盖广泛的餐饮品类。等:国际性的外卖平台。在本文中,我们将以美团外卖为例,展示如何抓取餐厅的菜单、价格和评价等数据。我们会使用Python的爬虫库,如Scrapy和Selenium,来解决抓取任务。本文详细介绍了如何使用Python爬虫抓取外卖平台上的餐厅菜单、价格、评价等信息。我们展示了如何使用Scrapy和Selenium抓取静态与动态网页数据,如何清洗和存储数据,并讨论了如何应对外卖平台的反爬虫机制。

2201_76125261的博客 1500

Rust组织管理(AI回答)

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

yaoct的博客 153

【QNX+Android虚拟化方案】01 - 芯片介绍

【QNX+Android虚拟化方案】01 - 芯片介绍

|~~~热爱生活、努力学习的小伙汁~~~| 2951

第1章 机器人SLAM算法工程师主要做什么的?(附SLAM学习路线及资料推荐)

对于想从事机器人与自动驾驶领域的在校大学生、研究生来说,建图定位算法工程师是一个极具发展潜力的岗位,而SLAM知识体系则是胜任该岗位的核心支撑。从基础的计算机工具、C++语言,到核心的开源框架、数学知识,再到硬件衔接与项目实践,每一个环节都不可或缺。建议大家结合自身兴趣确定侧重方向(如激光SLAM、融合定位),先通过开源项目建立实践认知,再补全理论知识,同时积极参与社区交流。

行知SLAM 959

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

目前市面上的远程工具(如向日葵、toDesk等)免费版基本上都卡的不行,而且收费版好像也会卡。如果有云服务的话,可以基于 RustDesk 的 hbbs / hbbr 自己部署一套,不过会碰到一个问题:每台电脑装完客户端,都得手动去设置里填三样东西——ID 服务器、中继服务器、Key。填错一个就连不上,还得远程指导同事操作。这篇记录两种解决办法,以及云端编译的完整流程。内容基于 RustDesk 1.5.3 的源码。

风声的专栏 605

华为OD机试 - 学校的位置 - 数学问题(Python/JS/C/C++ 2024 B卷 100分)

华为OD机试 2024E卷题库疯狂收录中,刷题。

学Java,找哪吒 455

Rust LeetCode443 算法题解

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

weixin_43379230的博客 103

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

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的博客 441

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

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

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

wfly blog 319

WINCC7.3破解文件

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

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

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

ZenovaEdgeOS的博客 558

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

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

olegja3d的博客 209

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

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

yaoct的博客 167

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

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

wuchangjian的专栏 115

Rust LeetCode334 算法题解

本文分析了 LeetCode 334 题“递增的三元子序列”的两种解法。暴力法(三重循环)时间复杂度为 O(n³),仅适用于小数据;最优解采用一次扫描贪心策略,维护 first(最小值)和 second(递增对第二元素的最小值),通过三个分支判断:若当前数大于 second,则存在三元递增子序列;否则更新 first 或 second。算法正确性基于不变式:first 始终为已遍历最小值,second 为可形成递增对的最小尾部。时间复杂度 O(n),空间复杂度 O(1),适用于大规模数据。

weixin_43379230的博客 340

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

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

2601_96785163的博客 285

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

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

aifannihao的博客 222

rust: Push & Pull Pattern

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

Geovin Du Dream Park 109

我用 RustyPaste 做 AI Agent 云端存储

RustyPaste 是一个用 Rust 编写的极简文件上传与 Pastebin 服务。可以用来存储和访问 AI Agent 生成的文件

藏云阁技术社区 240

拆解 lan-scanner:一个零依赖 Rust 局域网扫描器的并发模型

lan-scanner 以零依赖实现高效局域网扫描,核心在于精巧的并发模型:通过懒加载任务队列(Jobs)避免内存爆炸,用 Arc<Mutex<Jobs>> 共享任务源,结合 mpsc 通道实现线程池并行探测。Probe 枚举统一 ICMP ping 与 TCP 端口扫描,跨平台差异由 #[cfg] 条件编译处理,调用系统 ping 命令规避权限问题。drop(tx) 优雅关闭通道,确保所有工作线程退出。全靠标准库完成高并发、低资源消耗的扫描,是 Rust 并发编程的典范。

weixin_63115449的博客 184
上一篇: 浏览器端 AI 推理的未来:WebGPU 加 WASM 的化学反应的深度分析
下一篇: Rust 异步生态图谱:从 runtime 到 RPC 框架的全景介绍与选型指南
第一程序员
博客等级 码龄1年 0粉丝 1822原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值