异步编程深潜:Tokio 运行时调度机制与并发模型

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

异步编程深潜:Tokio 运行时调度机制与并发模型

cover

一、高并发 I/O 的性能天花板——为什么需要异步运行时

网络服务的性能瓶颈几乎永远在 I/O,而非 CPU。一个典型的 HTTP 服务,处理一次请求的 CPU 计算可能只需 50 微秒,但等待数据库查询、缓存读取和下游服务响应的时间可能高达 10-50 毫秒。如果每个请求占用一个操作系统线程,那么 1000 个并发请求就需要 1000 个线程,每个线程 8MB 栈空间,仅栈内存就消耗 8GB。

操作系统线程的创建、切换和销毁都有不可忽视的代价。线程上下文切换涉及寄存器保存/恢复、TLB 刷新和缓存失效,在 Linux 上单次切换的延迟约 1-10 微秒。当线程数达到数千时,上下文切换的开销可能超过实际工作的时间。

Rust 的异步模型通过"用户态调度"解决这个问题:用轻量级的协程(Future)替代操作系统线程,由运行时在用户态完成调度,上下文切换的代价从微秒级降低到纳秒级。Tokio 是 Rust 生态中最成熟的异步运行时,本文将深入其调度机制和并发模型。

二、Tokio 运行时架构:从 Future 到任务调度的完整链路

Tokio 的核心架构由三层构成:Future 抽象层、任务调度层和 I/O 驱动层。理解这三层的协作方式,是写好异步代码的基础。

graph TD
    subgraph "Future 抽象层"
        A[async fn / async block] -->|编译器转换| B[impl Future]
        B -->|poll 方法| C[状态机驱动]
    end

    subgraph "任务调度层"
        D[任务 Task] -->|提交| E[工作窃取调度器]
        E -->|分配| F[Worker 线程]
        F -->|窃取| G[其他 Worker 的队列]
    end

    subgraph "I/O 驱动层"
        H[epoll / kqueue] -->|就绪事件| I[Waker 唤醒]
        I -->|重新入队| D
    end

    C -->|返回 Pending + 注册 Waker| H
    C -->|返回 Ready| J[任务完成]

    style E fill:#e8f4fd,stroke:#333
    style H fill:#fff3e0,stroke:#333
    style I fill:#e8f5e9,stroke:#333

2.1 Future 的 poll 模型:协作式调度的核心

Rust 的异步模型基于 poll 语义,而非回调或协程。每个 Future 有一个 poll 方法,返回 Poll::Ready(T) 或 Poll::Pending。返回 Pending 时,Future 必须注册一个 Waker,当数据就绪时由 I/O 驱动调用 Waker 将任务重新加入调度队列。

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

/// 自定义 Future:延迟返回一个值
/// 展示 poll 模型的核心机制
struct Delay {
    when: tokio::time::Instant,
    value: Option<String>,
}

impl Future for Delay {
    type Output = String;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        if tokio::time::Instant::now() >= self.when {
            // 时间已到,返回 Ready
            Poll::Ready(self.value.take().expect("Delay 被 poll 了两次"))
        } else {
            // 时间未到,注册 Waker 并返回 Pending
            // Waker 会在指定时间到达时被 tokio 的定时器唤醒
            cx.waker().wake_by_ref();
            Poll::Pending
        }
    }
}

这个模型的关键洞察是:Future 本身不做任何事,只有被 poll 时才推进状态。调度器决定何时 poll 哪个 Future,I/O 驱动决定何时唤醒哪个 Waker。这种分离使得调度策略可以灵活调整,而不影响 Future 的实现。

2.2 工作窃取调度器:多核利用的关键

Tokio 的多线程调度器采用工作窃取(Work Stealing)算法。每个 Worker 线程维护一个本地任务队列,新任务优先放入当前 Worker 的队列。当某个 Worker 的队列为空时,它会从其他 Worker 的队列尾部"窃取"任务。

这种设计的优势在于:任务在大多数情况下由同一个 Worker 执行,利用了 CPU 缓存的局部性;当负载不均衡时,空闲 Worker 会主动窃取任务,避免某些 Worker 过载而其他 Worker 空闲。

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

/// 多线程调度器下的 TCP Echo 服务
/// 每个连接由一个独立的 Task 处理,调度器自动分配到不同 Worker
#[tokio::main(flavor = "multi_thread", worker_threads = 4)]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
    println!("Echo 服务启动,监听 127.0.0.1:8080");

    loop {
        let (socket, addr) = listener.accept().await?;
        println!("新连接: {}", addr);

        // 为每个连接 spawn 一个独立 Task
        // Task 可能被调度到任意 Worker 线程执行
        tokio::spawn(async move {
            if let Err(e) = handle_echo(socket).await {
                eprintln!("连接 {} 处理错误: {}", addr, e);
            }
        });
    }
}

async fn handle_echo(mut socket: TcpStream) -> Result<(), std::io::Error> {
    let mut buf = vec![0u8; 4096];

    loop {
        // async read:当数据未就绪时自动返回 Pending,释放 Worker 线程
        let n = socket.read(&mut buf).await?;
        if n == 0 {
            return Ok(()); // 连接关闭
        }

        // async write:当内核发送缓冲区满时返回 Pending
        socket.write_all(&buf[..n]).await?;
    }
}

2.3 I/O 驱动:epoll/kqueue 与 Waker 的协作

Tokio 的 I/O 驱动是对操作系统多路复用机制(Linux epoll、macOS kqueue、Windows IOCP)的封装。当 Future 执行异步 I/O 操作时,Tokio 将文件描述符注册到 epoll 实例,并关联一个 Waker。当 epoll 返回就绪事件时,Tokio 调用对应的 Waker,将任务重新加入调度队列。

sequenceDiagram
    participant T as Task (Future)
    participant S as 调度器
    participant W as Worker 线程
    participant E as I/O 驱动 (epoll)

    T->>S: poll() → Pending (注册 Waker)
    S->>W: 切换到其他 Task
    W->>W: poll 其他就绪的 Task

    Note over E: 数据到达,epoll 返回就绪事件
    E->>S: 调用 Waker::wake()
    S->>W: 将 Task 重新加入队列
    W->>T: poll() → Ready(数据)

三、生产级异步代码:Select、Join 与超时控制

3.1 tokio::select!:多路复用的异步版本

select! 宏允许同时等待多个异步操作,哪个先完成就处理哪个。这是实现超时、取消和竞态选择的核心工具:

use tokio::sync::mpsc;
use tokio::time::{self, Duration};

/// 消息处理器:支持超时和优雅关闭
async fn message_processor(
    mut rx: mpsc::Receiver<String>,
    mut shutdown: tokio::sync::watch::Receiver<bool>,
) {
    let mut interval = time::interval(Duration::from_secs(30));

    loop {
        tokio::select! {
            // 分支 1:接收消息
            msg = rx.recv() => {
                match msg {
                    Some(content) => {
                        process_message(&content).await;
                    }
                    None => {
                        // 通道关闭,退出循环
                        println!("消息通道已关闭");
                        break;
                    }
                }
            }

            // 分支 2:定时心跳
            _ = interval.tick() => {
                send_heartbeat().await;
            }

            // 分支 3:关闭信号
            _ = shutdown.changed() => {
                println!("收到关闭信号,正在优雅退出...");
                break;
            }
        }
    }
}

async fn process_message(msg: &str) {
    // 实际的消息处理逻辑
    println!("处理消息: {}", msg);
}

async fn send_heartbeat() {
    println!("发送心跳");
}

3.2 JoinSet:并发任务池与结果收集

当需要并发执行多个同类任务并收集结果时,JoinSet 比 join! 更灵活:

use tokio::task::JoinSet;
use std::collections::HashMap;

/// 并发请求多个 URL,收集成功结果
/// 任何单个请求失败不影响其他请求
async fn fetch_all(urls: Vec<String>) -> HashMap<String, String> {
    let mut set = JoinSet::new();
    let client = reqwest::Client::new();

    // 为每个 URL 创建并发任务
    for url in urls {
        let client = client.clone();
        set.spawn(async move {
            let result = client
                .get(&url)
                .timeout(Duration::from_secs(10))
                .send()
                .await;

            match result {
                Ok(resp) => match resp.text().await {
                    Ok(body) => Some((url, body)),
                    Err(e) => {
                        eprintln!("读取响应体失败 {}: {}", url, e);
                        None
                    }
                },
                Err(e) => {
                    eprintln!("请求失败 {}: {}", url, e);
                    None
                }
            }
        });
    }

    // 收集所有成功的结果
    let mut results = HashMap::new();
    while let Some(result) = set.join_next().await {
        match result {
            Ok(Some((url, body))) => {
                results.insert(url, body);
            }
            Ok(None) => continue, // 单个请求失败,跳过
            Err(e) => {
                eprintln!("任务执行异常: {}", e);
            }
        }
    }

    results
}

3.3 超时与取消:防止任务无限挂起

use tokio::time::timeout;

/// 带超时的数据库查询
/// 超时后自动取消 Future,释放资源
async fn query_with_timeout(
    pool: &sqlx::PgPool,
    sql: &str,
) -> Result<sqlx::Row, AppError> {
    match timeout(Duration::from_secs(5), sqlx::query(sql).fetch_one(pool)).await {
        Ok(result) => result.map_err(AppError::Database),
        Err(_) => {
            // 超时:Future 已被 drop,数据库连接被归还到连接池
            Err(AppError::Timeout("数据库查询超时(5秒)".to_string()))
        }
    }
}

#[derive(Debug)]
enum AppError {
    Database(sqlx::Error),
    Timeout(String),
}

四、异步运行时的代价:内存开销、调试困难与生态约束

Tokio 不是免费的午餐。异步运行时在多个维度上引入了工程代价。

内存开销。每个 Task 需要独立的栈空间(默认 256KB-2MB,取决于配置)和状态机存储。大量并发 Task 的内存占用可能超过预期。此外,Tokio 的 I/O 驱动需要维护 epoll 实例和 Waker 注册表,这些也有固定开销。对于短生命周期的轻量任务,同步模型可能比异步模型更高效——异步的优势在于高并发 I/O,而非低延迟计算。

调试困难。异步代码的调用栈是断裂的——await 点之间的代码可能在不同时间、不同线程上执行。传统的调试器难以追踪异步调用链。Tokio 提供了 tokio-console 工具用于实时监控 Task 状态,但配置和使用门槛较高。当 Task 泄漏(spawn 但永远不完成)时,排查难度远超同步代码。

生态约束。Tokio 和 async-std 是两个不兼容的异步运行时。使用 Tokio 的库(如 hyper、tonic)无法直接在 async-std 上运行,反之亦然。这意味着选择运行时不仅是技术决策,也是生态绑定。目前 Tokio 在生态上占据主导地位,但这个分裂局面短期内不会消失。

跨 await 借用的限制。Rust 的借用检查器要求引用在 await 点之间保持有效,但 Future 可能被移动到其他线程执行。这意味着不能在 await 点之间持有对栈上数据的引用,必须使用 'static 生命周期或 Arc 共享所有权。这是 Rust 异步编程最常遇到的编译错误之一。

五、总结

Tokio 运行时通过 Future 的 poll 模型、工作窃取调度器和 I/O 驱动三层架构,实现了高并发 I/O 的用户态调度。poll 模型将异步推进的时机交由调度器决定,工作窃取算法优化了多核利用率和缓存局部性,I/O 驱动将操作系统的多路复用机制封装为 Waker 唤醒链路。

生产级异步代码需要掌握三个核心工具:select! 用于多路复用和竞态选择、JoinSet 用于并发任务池管理、timeout 用于防止任务无限挂起。但异步运行时也带来了内存开销、调试困难、生态分裂和跨 await 借用限制等代价。

落地路线建议:从单线程调度器(flavor = "current_thread")入手理解 poll 模型;再切换到多线程调度器体验工作窃取;最后在真实项目中应用 select、JoinSet 和超时控制。始终记住:异步的优势在高并发 I/O,对于 CPU 密集型任务,应使用 spawn_blocking 委托给操作系统线程。

基于单片机智能家居控制系统设计 *单片机设计介绍,基于单片机智能家居控制系统设计。 阅读详情

相关推荐

医学图像分割实战:基于TransUNet训练自己的眼底硬渗出物数据集(附完整代码)

本文详细介绍了基于TransUNet的眼底硬渗出物分割实战指南,涵盖数据预处理、模型调优、训练策略及性能优化等关键环节。通过代码复现和实验对比,展示了TransUNet在医学图像分割中的优势,为糖尿病视网膜病变的早期诊断提供技术支持。

weixin_42524708的博客 365

Rust 异步编程深潜:Tokio 运行时的调度机制,从 Future 到任务调度

Rust 的异步编程基于轮询模型,Future 是惰性的,必须由运行时驱动。Tokio 是当前最成熟的异步运行时,提供了工作窃取调度器、任务管理和 I/O 驱动。CLI 工具用单线程运行时,服务端程序用多线程运行时CPU 密集型任务用,不要在 async 函数中直接计算用Semaphore控制并发上限,防止资源耗尽用和tracing辅助调试异步问题统一使用 Tokio 运行时,避免混用不同运行时的库异步编程不是万能的。如果你的场景是纯 CPU 计算,同步代码可能更简单、更快。

no1coder的博客 5938

昇腾910B多卡环境下hccl-test性能调优实战

本文详细介绍了昇腾910B多卡环境下hccl-test性能调优的实战经验,包括环境搭建、CANN工具链配置、性能测试与高级调优技巧。通过优化缓冲区、PCIe拓扑和中断亲和性设置,显著提升多卡通信效率,为AI训练提供稳定高效的计算支持。

weixin_29216049的博客 856

深入 tokio::spawn 与任务派发机制

在 Tokio 中,每一次都会创建一个轻量线程(更准确地说,是一个异步任务)。任务本质上是包装在 Tokio 调度器中的一个Future,调度器负责在事件循环中轮询它,直到返回。无需操作系统线程,运行在 Tokio 的工作线程池中;每个任务之间相互独立,任务结束后自动释放资源;通过JoinHandle与调度器交互,可等待结果或捕获 panic;默认要求Send'static,以支持任务在多线程调度器间移动。理解任务模型是掌握的基础。

HeiquanMama的博客 1000

无符号整数、带符号整数溢出问题

让我们详细讲解一下带符号整数溢出和无符号整数溢出问题中,符号标志位 (SF)、零标志位 (ZF) 和进位标志位 (CF) 的行为方式

weixin_49342084的博客 2093

Tokio 多线程调度器架构:从线程池到 I/O 驱动的一万米深潜

摘要:本文深入解析 Tokio 异步运行时核心机制,通过手写微缩 Runtime(200行代码)揭示工作窃取调度器、I/O驱动与任务执行的协作原理。主要内容包括: 实现跨NUMA节点的工作窃取线程池,对比默认配置性能提升30% 使用BPF工具实时追踪调度事件 提供生产环境调优指南(线程绑定、任务分块、缓存对齐等) 剖析epoll/kqueue与定时器集成方案 给出最小Tokio Runtime实现范例及其性能测试数据

2401_86807180的博客 993

qemu-system-aarch64参数详解与实战配置指南

本文详细解析了qemu-system-aarch64的核心参数,包括-machine、cpu、smp、m、drive和netdev等关键配置。通过嵌入式内核调试、完整系统运行和外设模拟三大实战场景,提供可直接使用的配置示例与性能优化技巧,帮助开发者在x86主机上高效构建和调试ARM64虚拟环境。

weixin_29197051的博客 353

Rust与Node.js内存管理深度对比:从GC到零成本抽象的技术选型指南

内存管理是后端服务性能优化的核心议题,其实现原理直接决定了系统的资源效率与稳定性。垃圾回收(GC)机制通过运行时自动管理内存,为开发者提供了便利,但引入了堆内存膨胀与GC停顿的不确定性开销。相比之下,零成本抽象理念通过在编译期进行严格的所有权与生命周期检查,实现了确定性的内存分配与释放,从根源上避免了运行时GC开销。这种差异在长期运行、高并发的AI推理与微服务场景下价值凸显,能够显著降低内存占用、提升资源利用率,并为延迟敏感型应用提供更稳定的性能表现。本文以Rust和Node.js的对比为切入点,深入剖析了

weixin_33842304的博客 398

Axial Attention 和 Criss-Cross Attention及其代码实现

Axial Attention 和 Criss-Cross Attention及其代码实现 ​ 文章目录Axial Attention 和 Criss-Cross Attention及其代码实现1 Criss - Cross Attention介绍1.1 引言1.2 理论实现1.2.1 获取权重A1.2.2 Affinity操作1.3.3 全部信息获取1.3 代码实现1.3.1 官方实现1.3.2 纯pytorch实现2 Axial Attention 介绍2.1 引言2.2 理论实现2.3 代码实现2.3

fzl的博客 2万+

2篇1章1节:数据的基本概念以及 R 中的数据结构、向量与矩阵的创建及运算

本文详细介绍了R语言中常见的数据结构的向量和矩阵。通过掌握这些数据结构的基本概念和操作技巧,可以更高效地处理和分析数据。

MD Code 1246

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

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

qq_36765170的博客 571

【GameFramework框架内置模块】9、有限状态机(FSM)

这篇文章分享FSM有限状态机,了解过StarForce源码的同学相比都比较了解,GameFramework框架给我们抽象了一个Procedure流程的概念。这个Procedure流程可以方便的处理我们游戏从启动到游戏的各个流程阶段的处理逻辑,实现的核心就是FSM状态机,内部的Procedure流程就是不同的FsmState状态。接下来,就是FSM有限状态机的教程了。有限状态机(Finite-state machine,FSM)

优快云博客专家,Unity3D高级软件工程师,《Unity 3D从入门到实战》作者。 2535

rust: Fan-out/Fan-in Pattern

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

Geovin Du Dream Park 162

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

Rust组织管理(AI回答)

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

yaoct的博客 153

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

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

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

风声的专栏 626

Rust LeetCode443 算法题解

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

weixin_43379230的博客 121

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

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

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

wfly blog 395

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

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

ZenovaEdgeOS的博客 559

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

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

olegja3d的博客 211

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

Rust LeetCode334 算法题解

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

weixin_43379230的博客 342

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

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

2601_96785163的博客 287

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 115
上一篇: 浏览器端 AI 推理:WebAssembly 插件架构与性能边界
下一篇: AI 辅助编程学习:工具选型、提示工程与知识内化策略
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论 3
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值