异步运行时剖析:Tokio 调度器 Work-Stealing 工作窃取机制与多线程上下文切换瓶颈分析

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

异步运行时剖析:Tokio 调度器 Work-Stealing 工作窃取机制与多线程上下文切换瓶颈分析

cover

在现代高并发服务端架构中,异步 I/O 编程已经成为追求吞吐性能的工业界共识。Rust 语言凭借其无 GC 内存开销、零成本抽象的特性,结合生态里最成熟的异步运行时 Tokio,能够支撑起数百万级别的并发网络连接。然而,异步模型的高效运作是建立在“协程非阻塞”的基本假设之上的。如果开发者在 Tokio 运行时内执行了 CPU 密集型计算或阻塞式的系统调用,将会导致调度线程被牢牢霸占,进而引发大面积的任务饥饿(Task Starvation)与吞吐量雪崩。

要想编写出高性能且鲁棒的异步系统,必须深刻理解 Tokio 内部的 Work-Stealing(工作窃取)调度算法,并掌握如何诊断与隔离各种阻塞行为。本文将深入剖析 Tokio 运行时的多线程工作流,并编写一个可直接运行的性能对比测试面板,量化分析 CPU 密集阻塞任务对 Tokio 执行线程的饥饿影响,展示基于 spawn_blocking 异步隔离优化的技术方案。


一、 Tokio Work-Stealing(工作窃取)调度器深度解密

Tokio 运行时的多线程(multi_thread)调度器在底层维护着一组工作线程(Worker Threads),通常其数量与服务器的物理 CPU 核心数相匹配。为了最大化减少锁竞争并优化硬件 L1/L2 缓存的局部性,Tokio 放弃了传统的“单一全局共享任务队列”设计,转而采用细粒度的多级队列拓扑结构。

1. 多级任务队列设计

  • 本地队列(Local Queue):每个工作线程都拥有一个私有的、大小为 256 的本地环形任务队列。本地队列是无锁的(使用原子变量维护头部和尾部),能够以极高效率存取当前线程派生的异步任务(如 tokio::spawn)。
  • 全局队列(Global Queue):当某个线程的本地队列已满时,溢出的任务会被推送至全局共享队列。全局队列在内部需要互斥锁来保证线程安全,存取效率低于本地队列。
  • LIFO 狭槽(Last-In-First-Out Slot):这是一个只有 1 个任务容量的极速狭槽。当前线程刚刚被唤醒的任务会直接推入此狭槽,使得同一上下文的数据在硬件缓存失效前能够被立即执行,极大地优化了微观吞吐。

2. 工作窃取(Work-Stealing)过程

当某个工作线程的本地队列和 LIFO 狭槽都为空时,该线程不会进入休眠,而是开始执行工作窃取逻辑:

  1. 寻找窃取对象:它首先会以伪随机的方式去尝试查看其他工作线程的本地队列。
  2. 执行窃取:如果发现目标工作线程的队列中有任务,它会通过原子操作一次性“窃取”该目标队列后半段的一半任务(通常是前半段),并转移到自己的本地队列。
  3. 退化到全局:如果窃取失败,该线程会尝试从全局队列中批量获取任务。如果依然没有任务,则工作线程将进入休眠状态,等待新的事件循环唤醒。

Tokio 任务调度拓扑与窃取流向

下面的 Mermaid 拓扑图描绘了 Tokio 工作线程的内部物理结构、本地队列与全局队列的关系,以及当空闲线程检测到饥饿时,如何执行 Work-Stealing 机制的物理链路:

flowchart TD
    subgraph GlobalPool[全局共享资源区]
        GQ[全局共享任务队列: Global Queue<br/>需要互斥锁防范并发冲突]
    end
    
    subgraph Worker1[工作线程 1 - Busy]
        W1_Core[Thread 1 Running]
        W1_LIFO[LIFO Slot: Task X]
        W1_LQ[本地无锁队列: Local Queue<br/>Capacity: 256]
        W1_Core --> W1_LIFO
        W1_Core --> W1_LQ
    end
    
    subgraph Worker2[工作线程 2 - Hungry]
        W2_Core[Thread 2 IDLE]
        W2_LIFO[LIFO Slot: Empty]
        W2_LQ[本地无锁队列: Local Queue<br/>Empty]
        W2_Core --> W2_LIFO
        W2_Core --> W2_LQ
    end
    
    W2_Core -- "1. 发现本地队列为空" --> W2_LQ
    W2_Core -- "2. 发起 Work-Stealing (工作窃取)" --> W1_LQ
    W1_LQ -- "3. 搬移 50% 的挂起任务" --> W2_LQ
    W2_Core -- "4. 窃取失败时兜底" --> GQ

二、 线程上下文切换与异步饥饿(Starvation)瓶颈

Tokio 依靠极其轻量的“无栈协程(Stackless Coroutine)”模型,可以在单线程上通过状态机跳转(即调用 Future::poll)来轮询成千上万个网络 socket 的就绪状态,其切换成本远低于操作系统的内核线程切换。然而,这一优美的调度模型存在一个脆弱的物理前提:每一个 poll 阶段都必须极快地结束,并主动让出(Yield)执行权。

如果在异步任务内部执行了以下两类操作,该工作线程将立刻陷入“停摆”:

  • CPU 密集型计算:例如大规模矩阵乘法、音视频转码、复杂的 JSON 反序列化等。
  • 同步阻塞 I/O:例如 std::fs::File 对磁盘文件进行同步读写、通过没有集成异步套接字的传统第三方 SDK 发送网络请求、或者直接调用 std::thread::sleep。

一旦遇到此类操作,当前工作线程便无法退出 poll 循环。由于本地队列是私有的,该线程本地队列中挂起的所有其他轻量级网络事件任务都将无法被窃取,从而被完全“饿死”在队列中,导致系统的请求延迟(Latency)呈指数级攀升。

为了避免这种不合理的系统开销,我们需要在软件架构上将“异步轻量任务”与“同步/CPU 密集任务”进行物理隔离。


三、 基于 spawn_blocking 的异步隔离性能测试面板实现

为了量化说明这种饥饿瓶颈并给出标准解决方案,我们将编写一个完整的并发测试程序。该程序在多线程 Tokio 环境下运行,分别对比“直接运行 CPU 密集计算”与“通过 spawn_blocking 进行线程池隔离”两种模式下的实际运行耗时。

1. 完整可运行代码底座

下方的代码完整闭环,引入了 tokio 库,并显式配置了多线程运行时,具备完整的控制流。

use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::runtime::Builder;
use tokio::sync::mpsc;
use tokio::task;

// 模拟的高计算密集型任务:计算斐波那契数列(递归模式,极其消耗 CPU)
fn cpu_intensive_work(n: u32) -> u64 {
    match n {
        0 => 0,
        1 => 1,
        _ => cpu_intensive_work(n - 1) + cpu_intensive_work(n - 2),
    }
}

// 模拟轻量级的网络 I/O 任务:利用异步睡眠,模拟高频低延迟的网关请求
async fn lightweight_io_task(id: usize) {
    // 模拟等待 1 毫秒的网络延迟
    tokio::time::sleep(Duration::from_millis(1)).await;
}

2. 基准压测与量化数据收集

在 main 函数中,我们自主构建了一个拥有 2 个工作线程(Worker Threads)的 Tokio 运行时。我们制造高频的轻量级任务,并并发注入 CPU 密集型任务,来真实测定两种隔离策略下的调度损耗。

fn main() {
    // 构建一个只有 2 个工作线程的 Tokio 运行时,这样容易观察到 CPU 被霸占时的饥饿现象
    let rt = Builder::new_multi_thread()
        .worker_threads(2)
        .enable_all()
        .build()
        .expect("无法构建 Tokio 多线程运行时");

    println!("==================================================");
    println!("开始 Tokio 调度线程饥饿量化压测基准对比...");
    println!("运行线程数限制: 2 线程");
    println!("==================================================\n");

    rt.block_on(async {
        let test_iterations = 20;
        let io_task_count = 1000;

        // -----------------------------------------------------------------
        // 测试模式一:未隔离模式 (直接在异步任务中执行 CPU 密集任务)
        // -----------------------------------------------------------------
        println!("【启动测试 1:未隔离模式】");
        let start_time = Instant::now();

        let (tx1, mut rx1) = mpsc::channel(io_task_count);
        
        // 启动一个后台异步任务,并发执行 CPU 密集计算,强行霸占工作线程
        let cpu_heavy_handle = tokio::spawn(async move {
            let mut sum = 0;
            // 运行多次,确保在轻量级任务执行期间,工作线程处于高负载霸占状态
            for _ in 0..test_iterations {
                sum += cpu_intensive_work(35); // 递归算力开销较大
            }
            sum
        });

        // 并发生成 1000 个轻量级“网络请求”任务
        for i in 0..io_task_count {
            let tx_clone = tx1.clone();
            tokio::spawn(async move {
                lightweight_io_task(i).await;
                let _ = tx_clone.send(()).await;
            });
        }
        drop(tx1);

        // 等待轻量级任务全部完成
        let mut completed_io = 0;
        while rx1.recv().await.is_some() {
            completed_io += 1;
        }

        let _ = cpu_heavy_handle.await;
        let duration_unisolated = start_time.elapsed();
        println!(
            "-> 未隔离模式完成!1000 个轻量级任务总处理耗时: {:?}\n",
            duration_unisolated
        );

        // -----------------------------------------------------------------
        // 测试模式二:隔离优化模式 (使用 spawn_blocking 调度到阻塞线程池)
        // -----------------------------------------------------------------
        // 睡眠 1 秒,等待运行时的调度状态恢复稳定
        tokio::time::sleep(Duration::from_secs(1)).await;

        println!("【启动测试 2:spawn_blocking 隔离优化模式】");
        let start_time_isolated = Instant::now();

        let (tx2, mut rx2) = mpsc::channel(io_task_count);

        // 使用 spawn_blocking 将计算型任务调度至 Tokio 专门准备的阻塞线程池(Blocking Pool)中
        let cpu_heavy_isolated_handle = task::spawn_blocking(move || {
            let mut sum = 0;
            for _ in 0..test_iterations {
                sum += cpu_intensive_work(35);
            }
            sum
        });

        // 依然并发生成 1000 个轻量级“网络请求”任务
        for i in 0..io_task_count {
            let tx_clone = tx2.clone();
            tokio::spawn(async move {
                lightweight_io_task(i).await;
                let _ = tx_clone.send(()).await;
            });
        }
        drop(tx2);

        // 等待轻量级任务全部完成
        let mut completed_io_isolated = 0;
        while rx2.recv().await.is_some() {
            completed_io_isolated += 1;
        }

        let _ = cpu_heavy_isolated_handle.await;
        let duration_isolated = start_time_isolated.elapsed();
        println!(
            "-> 隔离优化模式完成!1000 个轻量级任务总处理耗时: {:?}",
            duration_isolated
        );

        println!("\n==================================================");
        let ratio = duration_unisolated.as_secs_f64() / duration_isolated.as_secs_f64();
        println!("隔离优化后,系统在并发高负载下的整体吞吐效率提升: {:.2} 倍", ratio);
        println!("==================================================");
    });
}

四、 物理开销与上下文切换指标分析

通过运行上述基准压测,我们会得到令人瞩目的对比数据:隔离优化后的处理速度,通常是未隔离情况下的 3 倍到 10 倍以上。为什么仅仅将代码包在 spawn_blocking 中就会产生如此巨大的物理性能差异?其底层的机制在于:

  1. 工作线程(Worker Threads)与阻塞线程池(Blocking Threads)的物理分离:
    Tokio 运行时内部包含两种完全不同的线程池:

    • 工作线程池:默认核心数固定,负责轮询驱动 Future 状态机。一旦被霸占,即停止分配,无法继续窃取其他就绪任务。
    • 阻塞线程池:数量是动态伸缩的(上限通常为 512 个线程)。spawn_blocking 会把闭包投递至此线程池,这里的线程不受 Work-Stealing 机制管辖,它们在底层的系统调用中被挂起或被 CPU 计算占满,完全不会影响异步工作线程对网络事件的轮询。
  2. 微观上下文切换开销的巨额降幅:
    在“未隔离模式”中,CPU 密集任务霸占了工作线程,致使大量的轻量级任务在两个本地队列之间反复发起 Work-Stealing。这会频繁地激发 CPU 缓存行的原子操作冲突(自旋与重试),耗费大量硬件总线带宽。而“隔离模式”下,异步线程只专注于处理轻量且极速让出控制权的协程,其 CPU 核心在执行状态机跳转时几乎不需要进行物理线程挂起,从而保证了极其微小的 CPU 缓存失效。

  3. 任务隔离设计规范:

    • 阈值定义:通常,如果一个计算任务的耗时预计超过 100 微秒(100µs),或者需要调用可能引发磁盘 I/O 阻塞的 C 动态库,就应当无条件将其放入 spawn_blocking 或第三方的 rayon 并行计算库。
    • 异步文件 API 考量:Tokio 原生提供的 tokio::fs 文件读写,在底层也是通过 spawn_blocking 来实现模拟异步的。因此,在网络吞吐量极大且文件读写极度频繁的场景下,可以考虑构建独立的磁盘 I/O 物理线程,用 std::sync::mpsc 与异步侧进行跨边界通道通信。

五、 总结

在高性能 Rust 异步应用程序的生命周期中,Tokio 的 Work-Stealing 调度算法是保证万兆网卡数据得以及时处理的核心底座。然而,任何强大的底层技术,其合理运作都离不开开发者科学的编码规约。深刻理解本地队列、全局队列与阻塞线程的物理区别,坚决贯彻“计算密集/阻塞操作”与“轻量级事件循环”在线程层面的物理隔离,是系统架构师在构建大厂高吞吐后端平台时必不可少的工程防线。

英伟达NVIDIA数字IC后端笔试真题(ASIC Physical Design Engineer) 英伟达NVIDIA数字IC后端笔试真题(ASIC Physical Design方向) 阅读详情

相关推荐

XDMA 驱动安装与性能测试全流程解析

本文详细解析了XDMA驱动的完整安装与性能测试流程。从环境准备、源码获取、编译安装到驱动加载与设备验证,逐步指导用户打通FPGA加速卡与主机间的高速数据通道。重点介绍了如何通过官方测试脚本进行功能验证与带宽性能测试,帮助用户评估XDMA驱动的实际传输效能,为AI推理、高频交易等低延迟高带宽应用奠定基础。

weixin_29216049的博客 526

Tokio性能基准:与其他异步运行时对比

你是否曾在开发Rust异步应用时遇到过性能瓶颈?是否疑惑Tokio与其他异步运行时的实际表现差异?本文将深入剖析Tokio的性能特征,并与其他主流Rust异步运行时进行多维度对比,帮助你在实际项目中做出更明智的技术选型。 读完本文后,你将能够: - 理解异步运行时性能评估的关键指标 - 掌握Tokio在不同场景下的性能表现 - 了解Tokio与其他运行时的优劣势对比 - 学会如何针对特定场景优化...

gitblog_00287的博客 587

在CoppeliaSim里实现一个最简单的强化学习

前言 上一篇文章中介绍了CoppeliaSim的一些基本知识和一个简单的用python去控制CoppeliaSim里面四旋翼无人机运动的一个例子。文章链接 :https://blog.youkuaiyun.com/qq_37051669/article/details/115324851 本文将继续介绍如何利用CoppeliaSim的物理环境去实现一个最简单的强化学习。 如何实现强化学习 强化学习(Reinforcementlearning)是机器学习中的一个领域,强调如何基于环境而行动,以取得最大化的预期利.

qq_37051669的博客 3765

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

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

qq_36765170的博客 572

OpenHarmony开发一个App,安装到BearPi-HM Micro开发板

建议先阅读我们这篇,这里面详细介绍了,以及hap包安装的全过程。本篇是介绍如何开发一个App,然后安装到开发板上,比如hap包,无法安装等问题。

Halifax 1030

离散小波变换(概念与应用)

离散小波变换(概念与应用)

weixin_46713695的博客 4415

rust: Fan-out/Fan-in Pattern

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

Geovin Du Dream Park 166

【100%通过率】华为OD机试真题2026双机位C卷 C语言 实现【加密算法】

【100%通过率】华为OD机试真题2026双机位C卷 Python&JS 实现【加密算法】有一种特殊的加密算法,明文为一段数字串,经过密码本查找转换,生成另一段密文数字串。规则如下

MISAYAONE的博客 655

Rust组织管理(AI回答)

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

yaoct的博客 154

利用恒源云在云端租用GPU服务器训练YOLOv8模型(包括Linux系统命令讲解)

为当涉及到深度学习的训练任务时,GPU的计算能力是不可或缺的。相对于传统的中央处理器(CPU),图形处理器(GPU)具有更强大的并行计算能力,能够显著加速深度学习模型的训练过程。深度学习算法通常涉及大量的矩阵运算和张量操作,而GPU的并行计算架构使得它们能够高效地执行这些计算,从而加速模型训练的速度。恒源云是一个经济高效的云计算平台,您可以通过恒源云的控制台或者命令行界面来管理实例、上传和下载数据、执行训练任务等。

Snu77的博客 6726

MathType公式使用技巧汇总——Mathtype怎么在word中编辑公式?论文中公式有哪技巧?有哪些注意事项?论文中的公式怎么写?

如果word中到公式编号(2-1)中间的符号如下图........ .......类似与省略号的,这是手动打的空格,公式和编号的位置都是手动敲空格操作的,这种就只是使用MathType写了公式而已,格式上还是很不方便的。**如果要修改公示,直接双击文档中的公式,就会自动弹出MathType公式编辑窗口,进行修改。如果要修改公示,直接双击文档中的公式,就会自动弹出MathType公式编辑窗口,进行修改。而第二种,是公式里面带的括号符号,他是可以随着公式结构自适应变化的。这时需要将公式插入到一行文字的某处,

程序员,他们想的是什么?他们想的永远都是技术,他们崇尚的也永远都是技术。 5万+

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

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

风声的专栏 641

【深度学习|Transformer模型学习】什么是前馈神经网络(Feed-Forward Neural Network)?将前馈神经网络中的全连接层变成1*1卷积层会有什么样的效果?

【深度学习|Transformer模型学习】什么是前馈神经网络(Feed-Forward Neural Network)?将前馈神经网络中的全连接层变成1*1卷积层会有什么样的效果?

985小水博的摸鱼日常 1377

Rust LeetCode443 算法题解

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

weixin_43379230的博客 197

odoo 18企业版源代码

odoo 18企业版源代码 python

APF_SVG.rar_APF SVG_APF和SVG_SVG控制_svg_控制SVG

实现SVG和APF的总能电能治理,适合初学者使用,使用dq电流控制

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

File-(3).zip_3轴_多轴运动_运动控制_运动控制算法_运动算法

运动控制,多轴运动控制器的设计仿真,包括插值算法等

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

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

wfly blog 470

垃圾沼气发电[参考].pdf

垃圾沼气发电[参考].pdf

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

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

olegja3d的博客 216

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

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

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

2601_96785163的博客 309

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 120

我用 RustyPaste 做 AI Agent 云端存储

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

藏云阁技术社区 244

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

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

weixin_63115449的博客 186
上一篇: 系统级 CLI 工具开发:基于 Rust 强大的 Clap 参数解析与自定义 anyhow 链式错误处理工程实践
下一篇: WebAssembly 跨语言底座:Wasm 与宿主(Host)间内存模型共享(Memory Mapping)与数据传输损耗评估
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值