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

一、异步运行时的调度瓶颈:从协作式到抢占式的演进

Rust 的 async/await 语法将异步代码编写简化为近乎同步的形式,但运行时调度的复杂性并未消失——它只是被隐藏到了 Tokio 运行时的内部。当数千个并发任务在少量操作系统线程上交替执行时,调度器的效率直接决定了系统的吞吐量与尾延迟。

Tokio 的多线程调度器采用 work-stealing(工作窃取)算法,这是现代并行运行时的主流调度策略。理解其底层机制,对于诊断异步应用的性能瓶颈(如任务饥饿、线程不平衡、尾延迟毛刺)至关重要。

二、Work-Stealing 调度器的核心数据结构

Tokio 的多线程调度器为每个工作线程维护一个本地队列(Local Queue),同时有一个全局队列(Global Queue)作为溢出缓冲。任务调度遵循"本地优先,窃取兜底"的策略。

graph TB
    subgraph Tokio 多线程调度器
        GQ[全局队列<br/>Global Queue<br/>无界 MPSC]

        subgraph Worker Thread 0
            LQ0[本地队列 0<br/>Local Queue<br/>256 容量环形缓冲]
            W0[工作线程 0<br/>执行任务]
            LQ0 --> W0
        end

        subgraph Worker Thread 1
            LQ1[本地队列 1<br/>Local Queue]
            W1[工作线程 1<br/>执行任务]
            LQ1 --> W1
        end

        subgraph Worker Thread N
            LQN[本地队列 N<br/>Local Queue]
            WN[工作线程 N<br/>执行任务]
            LQN --> WN
        end

        GQ -->|分发| LQ0
        GQ -->|分发| LQ1
        GQ -->|分发| LQN
    end

    subgraph Work-Stealing 流程
        W0 -->|本地队列空| STEAL[窃取策略]
        STEAL -->|从其他本地队列<br/>偷走一半任务| LQ1
        STEAL -->|从全局队列<br/>取一批任务| GQ
    end

    style GQ fill:#ffebee
    style LQ0 fill:#e1f5fe
    style LQ1 fill:#e1f5fe
    style LQN fill:#e1f5fe
    style STEAL fill:#fff3e0

本地队列:每个工作线程拥有一个固定容量(256)的无锁环形缓冲区。新 spawn 的任务优先放入当前线程的本地队列,避免全局锁竞争。本地队列采用侵入式链表实现,任务结构体本身作为链表节点,减少内存分配。

全局队列:当本地队列已满时,新任务溢出到全局队列。全局队列使用 MPSC(多生产者单消费者)通道实现,工作线程在本地队列空时从全局队列批量获取任务。

窃取策略:当工作线程的本地队列为空时,它首先尝试从全局队列获取任务;如果全局队列也为空,则从其他工作线程的本地队列"窃取"一半任务。窃取操作使用原子 CAS(Compare-And-Swap)实现无锁同步。

三、调度器核心逻辑的简化实现

3.1 本地队列:无锁环形缓冲区

use std::sync::atomic::{AtomicU16, AtomicU32, Ordering};
use std::cell::UnsafeCell;

const LOCAL_QUEUE_CAPACITY: usize = 256;

/// 简化的本地任务队列
/// 基于 Tokio 实际实现的 Intra-Queue 设计
pub struct LocalQueue {
    buffer: UnsafeCell<[Option<Task>; LOCAL_QUEUE_CAPACITY]>,
    head: AtomicU16,  // 消费者位置
    tail: AtomicU16,  // 生产者位置
    /// 窃取时使用的快照,防止并发窃取导致数据竞争
    steal_stamp: AtomicU32,
}

pub struct Task {
    pub id: u64,
    pub future_ptr: usize,  // 简化:实际为 Pin<Box<dyn Future>>
}

impl LocalQueue {
    pub fn new() -> Self {
        Self {
            buffer: UnsafeCell::new([None; LOCAL_QUEUE_CAPACITY]),
            head: AtomicU16::new(0),
            tail: AtomicU16::new(0),
            steal_stamp: AtomicU32::new(0),
        }
    }

    /// 推入任务(仅由所属工作线程调用,无竞争)
    pub fn push(&self, task: Task) -> Result<(), Task> {
        let tail = self.tail.load(Ordering::Relaxed);
        let head = self.head.load(Ordering::Acquire);

        // 计算队列长度
        let len = tail.wrapping_sub(head);
        if len >= LOCAL_QUEUE_CAPACITY as u16 {
            return Err(task); // 队列满,溢出到全局队列
        }

        // 写入缓冲区
        let index = tail as usize % LOCAL_QUEUE_CAPACITY;
        unsafe {
            (*self.buffer.get())[index] = Some(task);
        }

        self.tail.store(tail.wrapping_add(1), Ordering::Release);
        Ok(())
    }

    /// 弹出任务(仅由所属工作线程调用)
    pub fn pop(&self) -> Option<Task> {
        let tail = self.tail.load(Ordering::Relaxed);
        let head = self.head.load(Ordering::Relaxed);

        if head == tail {
            return None; // 队列空
        }

        let index = head as usize % LOCAL_QUEUE_CAPACITY;
        let task = unsafe {
            (*self.buffer.get())[index].take()
        };

        self.head.store(head.wrapping_add(1), Ordering::Release);
        task
    }

    /// 窃取任务(由其他工作线程调用)
    /// 返回窃取到的任务列表
    pub fn steal(&self) -> Vec<Task> {
        loop {
            let head = self.head.load(Ordering::Acquire);
            let tail = self.tail.load(Ordering::Acquire);
            let len = tail.wrapping_sub(head);

            if len == 0 {
                return Vec::new();
            }

            // 窃取一半任务(向下取整,至少窃取 1 个)
            let steal_count = (len / 2).max(1);
            let new_head = head.wrapping_add(steal_count);

            // CAS 更新 head,防止并发窃取
            if self.head.compare_exchange_weak(
                head,
                new_head,
                Ordering::AcqRel,
                Ordering::Acquire,
            ).is_ok() {
                let mut stolen = Vec::with_capacity(steal_count as usize);
                for i in 0..steal_count {
                    let index = (head.wrapping_add(i)) as usize % LOCAL_QUEUE_CAPACITY;
                    if let Some(task) = unsafe { (*self.buffer.get())[index].take() } {
                        stolen.push(task);
                    }
                }
                return stolen;
            }
            // CAS 失败,重试
        }
    }
}

3.2 工作线程主循环

use std::sync::Arc;
use std::sync::atomic::AtomicBool;

pub struct Worker {
    id: usize,
    local_queue: Arc<LocalQueue>,
    global_queue: Arc<GlobalQueue>,
    peers: Vec<Arc<LocalQueue>>,
    running: Arc<AtomicBool>,
}

/// 全局队列的简化接口
pub struct GlobalQueue {
    // 实际实现为 crossbeam-queue 或 MPSC channel
}

impl GlobalQueue {
    pub fn push(&self, _task: Task) {}
    pub fn pop_batch(&self, _max: usize) -> Vec<Task> { Vec::new() }
}

impl Worker {
    pub async fn run(&self) {
        while self.running.load(Ordering::Relaxed) {
            // 优先级 1:从本地队列获取任务
            if let Some(task) = self.local_queue.pop() {
                self.execute_task(task);
                continue;
            }

            // 优先级 2:从全局队列批量获取
            let batch = self.global_queue.pop_batch(LOCAL_QUEUE_CAPACITY / 2);
            if !batch.is_empty() {
                // 将第一个任务直接执行,其余放入本地队列
                for (i, task) in batch.into_iter().enumerate() {
                    if i == 0 {
                        self.execute_task(task);
                    } else {
                        let _ = self.local_queue.push(task);
                    }
                }
                continue;
            }

            // 优先级 3:从其他工作线程窃取
            let stolen = self.steal_from_peers();
            if !stolen.is_empty() {
                for (i, task) in stolen.into_iter().enumerate() {
                    if i == 0 {
                        self.execute_task(task);
                    } else {
                        let _ = self.local_queue.push(task);
                    }
                }
                continue;
            }

            // 所有队列都空:进入休眠,等待新任务唤醒
            self.park();
        }
    }

    fn steal_from_peers(&self) -> Vec<Task> {
        // 随机选择起始窃取目标,避免所有线程同时窃取同一个目标
        let start = rand::random::<usize>() % self.peers.len();

        for i in 0..self.peers.len() {
            let peer_idx = (start + i) % self.peers.len();
            if peer_idx == self.id {
                continue;
            }

            let stolen = self.peers[peer_idx].steal();
            if !stolen.is_empty() {
                return stolen;
            }
        }

        Vec::new()
    }

    fn execute_task(&self, task: Task) {
        // 实际执行:poll Future
        // 简化示意
        log::trace!("[Worker {}] 执行任务 {}", self.id, task.id);
    }

    fn park(&self) {
        // 休眠当前线程,等待操作系统唤醒
        // Tokio 使用 epoll/io_uring 的事件循环实现
        std::thread::yield_now();
    }
}

四、调度器的性能权衡与边界条件

4.1 任务饥饿与公平性

Work-stealing 调度器不保证 FIFO 顺序。如果工作线程持续产生新任务(如一个任务 spawn 多个子任务),这些子任务会在本地队列中优先执行,全局队列中的旧任务可能长时间得不到调度。Tokio 通过定期从全局队列取任务(每 61 次本地弹出后取 1 次全局)缓解饥饿问题,但并非完全消除。

4.2 窃取开销与缓存局部性

窃取操作需要访问其他线程的本地队列,这会导致缓存行失效(Cache Line Invalidation)。在 NUMA 架构上,跨 NUMA 节点的窃取开销更为显著。Tokio 的窃取策略(偷一半)在负载均衡与缓存局部性之间取折中——偷太少则均衡效果差,偷太多则破坏被窃取线程的缓存局部性。

4.3 本地队列溢出与全局队列瓶颈

本地队列容量固定为 256,当突发流量导致任务积压时,溢出到全局队列的任务需要经过全局锁。全局队列成为竞争热点后,吞吐量会急剧下降。生产环境中应避免在单个任务中 spawn 大量子任务,改用流式处理(Stream)控制并发度。

4.4 阻塞操作对调度器的影响

Tokio 的工作线程数量固定(默认等于 CPU 核心数)。如果某个任务执行了阻塞操作(如同步文件 I/O 或 CPU 密集计算),该工作线程无法调度其他任务,导致整体吞吐量下降。Tokio 提供了 spawn_blocking 将阻塞操作卸载到专用线程池,但开发者需要主动识别并使用。

五、总结

Tokio 的 work-stealing 调度器通过本地队列 + 全局队列 + 窃取策略的三层架构,在低延迟与高吞吐之间取得平衡。核心设计包括:本地队列的无锁环形缓冲区实现零竞争入队出队,窃取策略通过 CAS 原子操作实现无锁跨线程任务转移,定期从全局队列取任务缓解饥饿问题。

落地建议:第一,使用 tokio::spawn 而非 std::thread::spawn 创建并发任务,确保任务进入调度器管理;第二,阻塞操作必须使用 spawn_blocking,避免占用工作线程;第三,控制单个任务的 spawn 粒度,避免本地队列溢出导致全局队列瓶颈;第四,监控调度指标(任务队列长度、窃取频率),及时发现负载不均衡问题。

海外支付实战:虚拟信用卡订阅ChatGPT Plus等服务的完整指南 在跨境数字服务消费中,支付环节常因地区限制、银行风控等因素受阻。其核心原理在于国际信用卡交易需通过发卡行风控系统,而国内银行对高频、小额或商户名非常规的境外线上交易敏感,导致成功率不稳定。为解决这一痛点,虚拟信用卡技术应运而生,它通过服务商生成关联预充值账户的虚拟卡号,提供地域灵活性与资金可控性,显著提升了支付通过率。这项技术的价值在于以较低学习成本,为个人用户打通了访问ChatGPT Plus、Midjourney、Claude Pro等前沿AI服务的支付通道。其典型应用场景包括订阅各类海外SaaS、内容 阅读详情

相关推荐

不会ps,你也可以成为ps高手,最强傻瓜式人像一键磨皮美白瘦脸美妆PS插件

比如:美肤是用来去斑点的,如果效果不太理想,就加大百分比,反之就减小。瘦脸如果脸胖的就打开,正常的就关闭。所谓的一键调节,要不只能调节一种效果,要不就是个预设,然后让你自己再调。同时,该软件还加入了贴心的批量处理功能,能同时处理上千张照片,让您喝着茶也能将工作做完。、自动检测照片中的人脸,包括鼻子,嘴巴,耳朵,眼睛和眉毛。、依托强大的脸部识别功能,可以高效的对人物全身皮肤进行智能识别,处理,使肤质平滑、过渡均匀。,这是网上下载的模糊照片,经过简单处理,你可以发现,眼睛变的更亮,皮肤更白,眼袋消失。

心语家园 - www.xinyucn.cc 2905

Tokio 多线程调度器架构深度解析

摘要:本文深度解析Tokio多线程调度器架构,重点剖析了其Work-Stealing算法的核心设计。通过本地队列与全局队列的平衡机制、任务唤醒的精妙设计,以及精心设计的实验案例,揭示了Tokio调度器在性能优化、负载均衡和任务调度方面的卓越实现。文章还提供了生产环境最佳实践建议,包括线程数设置、任务粒度控制等,帮助开发者充分发挥Tokio的高性能异步特性。

shiernima的博客 524

SIPVicious实战指南:从零开始掌握VoIP渗透测试(Kali Linux环境)

本文为SIPVicious实战指南,详细介绍了在Kali Linux环境下进行VoIP渗透测试的完整流程。从环境准备与工具安装开始,逐步讲解如何使用svmap扫描SIP服务器、svwar枚举PBX分机号,以及svcrack进行密码安全测试,并整合svreport生成报告。旨在帮助安全从业者从零开始,系统掌握这套经典开源工具,在授权范围内有效评估VoIP系统的安全性。

weixin_29327977的博客 541

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

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

qq_36765170的博客 572

立创开源4G+GPS定位系统:基于微信小程序的低成本低功耗追踪方案

本文介绍了一个基于立创开源平台的超小型4G+GPS定位系统方案。该方案采用28mm*28mm主板,集成4G Cat.1通信与GPS定位,通过微信小程序“点灯专家”实现远程追踪管理,具备低成本、低功耗、易于部署的特点,适用于电动车、宠物、资产追踪等多种场景。

weixin_28895791的博客 396

Modelsim10.5_se安装(Win11)

modelsim是Mentor公司开发的优秀的HDL语言仿真软件。它能提供友好的仿真环境,采用单内核支持VHDL和Verilog混合仿真的仿真器。它采用直接优化的编译技术、Tcl/Tk技术和单一内核仿真技术,编译仿真速度快且编译的代码与平台无关。

m0_51186267的博客 9927

rust: Fan-out/Fan-in Pattern

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

Geovin Du Dream Park 166

[Linux项目实践] LCD Panel的硬件分析及调试

LCD硬件分析 项目使用3.5” TFT-LCD并且支持触摸控制。LCD的硬件可从几个方面学习:1)查看LCD的硬件连线。2)查看数据手册了解寄存器的控制。3)查看LCD DATASHEET了解硬件操作 1)LCD硬件连线 在图中有33个引脚,22根数据引脚和9根控制引脚。 LCD的工作原理:像素点是从左至右,从上至下逐个显示,LCD控制寄存器会从从内存中的framebuffer通

Terry_Yuan的技术专栏 3025

Rust组织管理(AI回答)

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

yaoct的博客 153

高速接口电平标准互连设计:LVPECL、PECL与LVDS的实战解析

本文深入解析了LVPECL、PECL与LVDS三种高速接口电平标准的互连设计实战。针对信号共模电压、阻抗匹配等核心差异,详细对比了直流耦合与交流耦合两种主流方案,并提供了电阻网络计算、布局布线要点及光模块等特殊场景下的选型建议,帮助工程师解决高速信号间的“翻译”难题,确保信号完整性。

weixin_29198045的博客 542

[PCIE5.0] 2.2.8.9 Optimized Buffer Flush/Fill (OBFF) Message

这段文字讲解的是 优化的缓冲区清空/填充(OBFF)消息,它是 PCI Express(PCIe)规范中的一个可选功能,用于向设备报告平台中央资源的状态。简单来说,OBFF 主要帮助设备了解当前平台资源(如缓存或内存)的状态,从而优化数据的处理和传输。这章重点内容如下。

系统固件工程师 541

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

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

风声的专栏 635

姿态传感器/陀螺仪之LSM6DSLTR应用驱动程序设计

* LSM6DSLTR I2C地址(SA0=1) *//* 初始化LSM6DSLTR传感器(加速度计±2g,陀螺仪±250°/s) *//* 加速度计灵敏度 *//* 角速度值(°/s) *//* I2C句柄 *//* 陀螺仪灵敏度 *//* 加速度值(g) *//* 温度值(°C) *//* 设备地址 *//* IF_INC=1: 自动增量地址 *//* 10Hz采样率 *//* 配置I2C1引脚:PB6->SCL, PB7->SDA *//* 转换为实际温度值(°C),参考手册中温度计算公式 */

corlin6688的博客 397

Rust LeetCode443 算法题解

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

weixin_43379230的博客 185

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

WINCC7.3破解文件

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

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

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

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

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

wfly blog 444

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

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

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

olegja3d的博客 213

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

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

ZenovaEdgeOS的博客 561

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

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

wuchangjian的专栏 115

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

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

yaoct的博客 169

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

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

weixin_43379230的博客 354

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

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

2601_96785163的博客 304

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 119

我用 RustyPaste 做 AI Agent 云端存储

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

藏云阁技术社区 242

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

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

weixin_63115449的博客 186
上一篇: Rust 生命周期省略规则:编译器如何自动推理生命周期的底层机制
下一篇: Cargo build.rs 构建脚本:从代码生成到条件编译的工程实践
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值