Tokio 异步运行时实战:任务调度、背压控制与优雅关闭的全链路解析

Rust+AWS本地部署LLM:Candle加载GGUF模型实战 大语言模型(LLM)本地部署是当前AI工程落地的核心能力之一,其本质是将模型推理能力从云端API解耦,通过量化、归档与轻量引擎实现可控、安全、低成本的运行。关键技术原理包括GGUF模型归档格式——它并非简单压缩,而是整合权重、分词器、量化元数据并支持内存映射(mmap)按需加载;以及Rust语言凭借所有权系统与tokio异步运行时,在内存安全、并发处理和二进制分发上的不可替代性。该技术路径显著提升EC2等云实例的资源利用率与服务稳定性,广泛应用于内部AI工具链搭建、私有化推理服务及脱离厂商锁定的生产环境。本 阅读详情

Tokio 异步运行时实战:任务调度、背压控制与优雅关闭的全链路解析

cover

一、Tokio 的"调度哲学":为什么 Rust 的异步运行时需要手动选择

Rust 的 async/await 只是语法糖——它把异步函数编译为状态机(Future),但 Future 不会自己执行,必须有运行时来驱动。这和 Go 的 goroutine 调度器内置在语言运行时中完全不同:Rust 把"谁来调度"的选择权交给了开发者。Tokio 是目前最成熟的 Rust 异步运行时,但它的调度策略、任务模型和关闭机制都有不少细节容易踩坑。

初学 Tokio 时最容易犯的错误是"在 async 函数里调用阻塞操作"——比如 std::thread::sleep 或同步文件 I/O。这会阻塞整个 OS 线程,导致同一线程上的其他 Future 无法被调度。理解 Tokio 的调度模型是正确使用它的前提:工作窃取(Work Stealing)、任务类型(spawn vs spawn_blocking)、背压控制(channel 容量)和优雅关闭(CancellationToken)。

二、Tokio 运行时的架构:调度器、任务池与 I/O 驱动

flowchart TB
    A[Tokio Runtime] --> B[调度器: Work-Stealing]
    A --> C[I/O 驱动: epoll/kqueue]
    A --> D[Timer 驱动: 时间堆]

    B --> B1[Worker 线程池: 默认 CPU 核心数]
    B1 --> B2[本地队列: 每线程无锁队列]
    B1 --> B3[全局队列: 跨线程窃取]
    B --> B4[阻塞线程池: spawn_blocking]

    C --> C1[TcpListener / TcpStream]
    C --> C2[UnixStream / UdpSocket]
    C --> C3[文件 I/O: 通过 spawn_blocking]

    D --> D1[tokio::time::sleep]
    D --> D2[tokio::time::interval]
    D --> D3[tokio::time::timeout]

    B2 & B3 --> E[tokio::spawn: 轻量级任务]
    B4 --> F[阻塞任务: 独立线程池]

    E --> G[Future 轮询: poll → Pending/Ready]
    F --> H[同步操作: std::fs / 阻塞 API]

三、Tokio 实战代码:从任务调度到优雅关闭

3.1 运行时配置与任务调度

/**
 * Tokio 运行时配置与任务调度
 * 演示不同类型的任务如何被调度执行
 */
use tokio::runtime::Runtime;
use tokio::task;
use std::time::Duration;

pub fn runtime_configuration_demo() {
    // 自定义运行时配置
    let runtime = Runtime::builder()
        .worker_threads(4)           // Worker 线程数
        .max_blocking_threads(16)    // 阻塞线程池上限
        .thread_stack_size(2 * 1024 * 1024)  // 栈大小 2MB
        .thread_name("my-tokio-worker")
        .enable_all()                // 启用 I/O + Timer
        .build()
        .expect("创建运行时失败");

    runtime.block_on(async {
        // 轻量级异步任务:在 Worker 线程上调度
        let handle1 = task::spawn(async {
            println!("异步任务1: 开始执行");
            tokio::time::sleep(Duration::from_millis(100)).await;
            println!("异步任务1: 执行完成");
            42
        });

        // 阻塞任务:在阻塞线程池上执行
        let handle2 = task::spawn_blocking(|| {
            println!("阻塞任务: 开始执行");
            // 模拟 CPU 密集型或阻塞 I/O 操作
            std::thread::sleep(Duration::from_millis(200));
            println!("阻塞任务: 执行完成");
            "阻塞结果"
        });

        // 并发等待所有任务
        let (r1, r2) = tokio::join!(handle1, handle2);
        println!("结果: {:?}, {:?}", r1, r2);
    });
}

/**
 * 任务调度策略对比
 * spawn: 轻量级,在 Worker 线程上非阻塞执行
 * spawn_blocking: 重量级,在专用线程池上执行阻塞操作
 * spawn_local: 在当前线程上执行(需 LocalSet)
 */
pub async fn task_scheduling_demo() {
    // 场景1: 大量轻量级 I/O 任务
    let mut handles = vec![];
    for i in 0..100 {
        handles.push(task::spawn(async move {
            // 模拟 HTTP 请求
            tokio::time::sleep(Duration::from_millis(10)).await;
            format!("请求{}完成", i)
        }));
    }

    // 使用 JoinSet 管理大量任务
    let mut join_set = task::JoinSet::new();
    for i in 0..100 {
        join_set.spawn(async move {
            tokio::time::sleep(Duration::from_millis(10)).await;
            format!("JoinSet任务{}完成", i)
        });
    }

    // 逐个收集结果
    while let Some(result) = join_set.join_next().await {
        if let Ok(msg) = result {
            // 处理完成的任务
        }
    }
}

3.2 背压控制:通道与限流

/**
 * 背压控制
 * 使用有界通道和 Semaphore 控制系统负载
 */
use tokio::sync::{mpsc, Semaphore, broadcast};
use std::sync::Arc;

/// 生产者-消费者模式(有界通道实现背压)
pub async fn backpressure_channel_demo() {
    // 有界通道:容量为 16,满时生产者阻塞
    let (tx, mut rx) = mpsc::channel::<String>(16);

    // 生产者:模拟快速数据源
    let producer = task::spawn(async move {
        for i in 0..100 {
            let msg = format!("消息{}", i);

            // send() 在通道满时 await,自动实现背压
            if tx.send(msg).await.is_err() {
                println!("消费者已关闭");
                break;
            }
            println!("发送: 消息{}", i);
        }
    });

    // 消费者:模拟慢速处理
    let consumer = task::spawn(async move {
        while let Some(msg) = rx.recv().await {
            println!("处理: {}", msg);
            tokio::time::sleep(Duration::from_millis(50)).await;
        }
    });

    let _ = tokio::join!(producer, consumer);
}

/// Semaphore 限流:控制并发数
pub async fn semaphore_rate_limit_demo() {
    let semaphore = Arc::new(Semaphore::new(5)); // 最多 5 个并发
    let mut handles = vec![];

    for i in 0..20 {
        let permit = semaphore.clone();
        handles.push(task::spawn(async move {
            // 获取许可(等待可用配额)
            let _permit = permit
                .acquire()
                .await
                .expect("Semaphore 已关闭");

            println!("任务{}: 开始执行(获得许可)", i);
            tokio::time::sleep(Duration::from_millis(100)).await;
            println!("任务{}: 执行完成", i);
            // _permit 在此处 drop,释放许可
        }));
    }

    for handle in handles {
        let _ = handle.await;
    }
}

/// Broadcast 通道:一对多消息分发
pub async fn broadcast_demo() {
    let (tx, _) = broadcast::channel::<String>(100);

    // 创建 3 个接收者
    let mut receivers = vec![];
    for id in 0..3 {
        let mut rx = tx.subscribe();
        receivers.push(task::spawn(async move {
            while let Ok(msg) = rx.recv().await {
                println!("接收者{}: 收到 {}", id, msg);
            }
        }));
    }

    // 发送消息
    for i in 0..5 {
        let _ = tx.send(format!("广播消息{}", i));
    }

    // 关闭发送端
    drop(tx);

    for receiver in receivers {
        let _ = receiver.await;
    }
}

3.3 优雅关闭:CancellationToken 与 graceful shutdown

/**
 * 优雅关闭
 * 使用 CancellationToken 通知所有任务停止
 * 确保正在处理的请求完成后再退出
 */
use tokio_util::sync::CancellationToken;
use tokio::signal;
use tokio::sync::watch;

pub async fn graceful_shutdown_demo() {
    let cancel_token = CancellationToken::new();

    // 启动多个工作任务
    let mut task_handles = vec![];
    for i in 0..5 {
        let token = cancel_token.clone();
        task_handles.push(task::spawn(async move {
            loop {
                // 检查取消信号
                if token.is_cancelled() {
                    println!("任务{}: 收到取消信号,开始清理", i);
                    // 执行清理逻辑
                    tokio::time::sleep(Duration::from_millis(100)).await;
                    println!("任务{}: 清理完成,退出", i);
                    break;
                }

                // 模拟工作任务
                tokio::select! {
                    _ = tokio::time::sleep(Duration::from_millis(200)) => {
                        println!("任务{}: 正在工作...", i);
                    }
                    _ = token.cancelled() => {
                        println!("任务{}: 被取消", i);
                        break;
                    }
                }
            }
        }));
    }

    // 监听 Ctrl+C 信号
    let token = cancel_token.clone();
    task::spawn(async move {
        signal::ctrl_c()
            .await
            .expect("监听 Ctrl+C 失败");
        println!("\n收到 Ctrl+C,开始优雅关闭...");
        token.cancel();
    });

    // 等待所有任务完成
    for handle in task_handles {
        let _ = handle.await;
    }
    println!("所有任务已优雅退出");
}

/// Watch 通道实现配置热更新
pub async fn config_hot_reload_demo() {
    let (config_tx, config_rx) = watch::channel("初始配置".to_string());

    // 工作任务:监听配置变更
    let worker = task::spawn(async move {
        let mut rx = config_rx.clone();
        loop {
            // wait_for_change 等待配置更新
            if rx.changed().await.is_err() {
                break;
            }
            let new_config = rx.borrow().clone();
            println!("配置已更新: {}", new_config);
        }
    });

    // 模拟配置更新
    tokio::time::sleep(Duration::from_millis(100)).await;
    config_tx.send("更新配置v2".to_string()).unwrap();

    tokio::time::sleep(Duration::from_millis(100)).await;
    config_tx.send("更新配置v3".to_string()).unwrap();

    drop(config_tx);
    let _ = worker.await;
}

四、Tokio 生产环境的常见陷阱与调优策略

阻塞操作误入 Worker 线程:在 async 函数中调用 std::fs::read_to_string、std::net::TcpStream 的同步方法、或 CPU 密集型计算,会阻塞 Worker 线程。Tokio 默认 Worker 线程数等于 CPU 核心数,一个线程被阻塞就少了一个调度单元。解决方案:I/O 用 tokio::fs,CPU 密集型用 spawn_blocking,或用 tokio::task::block_in_place 在多线程运行时中临时阻塞。

Channel 容量与内存溢出:mpsc::channel() 创建无界通道,生产者可以无限发送,消费者来不及处理就会 OOM。生产环境必须使用 mpsc::channel(capacity) 有界通道,容量设置建议为"消费者处理速率 × 可接受延迟"。例如消费者每秒处理 1000 条消息,可接受 1 秒延迟,则容量设为 1000。

任务泄漏与 JoinHandle 忽略:tokio::spawn 返回 JoinHandle,如果不 await 它,任务可能还在运行但无人关心——这叫"任务泄漏"。更危险的是,如果任务 panic 且 JoinHandle 被 drop,panic 会被静默吞掉。建议:关键任务的 JoinHandle 必须收集并 await;使用 JoinSet 管理一组相关任务;对 panic 使用 task::Builder::new().name("...") 标记任务名方便排查。

select! 的分支优先级:tokio::select! 中多个分支同时就绪时,优先执行第一个分支。如果取消分支放在最后,可能导致取消信号延迟处理。建议将取消/超时分支放在 select! 的第一个位置。

五、总结

Tokio 的核心是"Work-Stealing 调度器 + I/O 驱动 + Timer 驱动"三位一体。任务调度策略:I/O 密集型用 tokio::spawn(轻量级 Future),CPU 密集型用 spawn_blocking(独立线程池)。背压控制三件套:有界 Channel(生产者阻塞)、Semaphore(并发限流)、BufferedStream(I/O 限流)。优雅关闭使用 CancellationToken + select! 组合,确保正在处理的请求完成后才退出。生产环境最关键的纪律:永远不要在 async 函数中调用阻塞操作,永远使用有界通道。

并发本质:任务切换、状态保存与资源复用 并发是一种程序设计范式,核心在于通过任务切换和上下文保存,在有限硬件资源下实现高响应性与资源复用。它不依赖多核并行,而是解决I/O等待导致的CPU空转问题,技术价值体现在不阻塞主线程、提升吞吐与降低延迟。典型应用场景包括Web服务器高并发请求处理、实时交互界面保流畅、IoT设备多外设协同等。其底层共性——如async/await状态机、协程轻量调度、事件循环驱动——在Python、Go、Rust等语言中高度统一,是现代异步编程的基石。 阅读详情

相关推荐

Hermes大模型网关:Rust+Docker构建的生产级AI中间件

大模型网关是连接LLM、工具、用户与业务系统的AI中间件,核心在于协议转换、智能路由与状态协调。其技术原理涵盖高并发调度(如tokio协程)、容器化交付(Docker镜像契约)与四层解耦架构(接入层/调度层/工具层/模型层),显著提升AI服务的稳定性、安全性和可维护性。相比Python轻量框架,Rust实现的零成本抽象与内存安全带来更高QPS与更低P99延迟,而Docker封装则保障跨平台一致性与升级原子性。典型应用场景包括Telegram机器人自动化、多平台消息路由、RAG增强对话及Cron驱动的数字员工

weixin_33739523的博客 464

ZeroClaw执行机制解析:Rust异步调度与硬件实时控制

具身智能系统的核心挑战在于将高层指令可靠、低延迟地转化为物理动作,这本质上是时间敏感型多任务并发问题。其底层依赖分层执行模型——以裸机调度器保障微秒级确定性,用Tokio处理非确定性I/O,并通过零拷贝通道实现跨层协同。Rust的ownership模型与async/await范式在此类系统中展现出独特优势:既规避C语言的手动内存管理风险,又比传统RTOS更易构建可组合、可测试的状态机逻辑。ZeroClaw正是这一理念的工程落地,它不追求通用性,而是聚焦‘电机何时动、为何不动、如何安全停’这一执行本质。本文深

weixin_34074740的博客 114

Qdrant 深度拆解:35K Star 的 Rust 向量数据库,是如何把 HNSW、Payload 过滤和量化压缩揉成一台机器

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

yinghan2005的专栏 340

rust: Fan-out/Fan-in Pattern

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

Geovin Du Dream Park 158

【Infracture】【数据中心】第十三篇 Ai infra中的“现象→根因→方案→关键参数/落地”01

现象:同步 RL step 里 99 分位输出长度是中位数的几倍到几十倍,整批等最慢几条;CoT/数学/代码尤甚,GPU 空泡严重,generation 占整体 50–80%、推理任务可到 80%+。根因方案矩阵落地红线:staleness K 先小(1→2→调),长尾不丢弃只延后;记录每条轨迹 policy_version、tokenizer_version、logprob、expert_route,便于重算 advantage 时做 off‑policy 修正。部署形态:gateway(router)→

weixin_49199313的博客 379

【信息科学与工程学】【数据中心】第三十五篇 云计算数据中心的学科知识04

编号学科(课程)核心知识点在云计算/云存储/云网络/云安全/云MaaS中的作用代表教材/资料/论文 + 数学方程式列表工业界应用D1421​云原生数据库:TiDB​HTAP(混合事务/分析处理)、分布式SQL、水平扩展、强一致(Raft)、自动故障恢复、与MySQL兼容、TiFlash列式引擎提供弹性扩展的分布式数据库;支撑高并发在线交易与实时分析教材:《TiDB in Action》PingCAP(2020) 论文:《TiDB: A Raft-based HTAP Database》(2017)

weixin_49199313的博客 417

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

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

qq_36765170的博客 569

【UV打印机】RYPC打印软件教程(二)-软件界面概述

下图是控制软件的主操作界面.将喷绘机的操作规纳为四块,分别为参数设置,任务选择,打印控制,系统维护,对于日常打印而言,只需操作任务选择,打印控制。从而使汲及的操作相对较少,使得系统对普通用户而言简单易用.

Print World的专栏 3605

Rust组织管理(AI回答)

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

yaoct的博客 153

“傻瓜”stata入门——熟悉操作界面

小白开始学习stata和matlab,零基础上手

nnpersistent的博客 4461

从零到一:基于Rocky Linux 9的Kubernetes高可用集群部署实战

本文提供了一份基于Rocky Linux 9操作系统,从零开始部署Kubernetes高可用集群的完整实战指南。详细讲解了包括系统初始化、容器运行时配置、使用kubeadm工具进行集群初始化、节点加入以及Calico网络插件安装在内的核心步骤,并针对国内网络环境提供了镜像加速等优化方案,旨在帮助读者构建一个稳定可靠的生产级K8s环境。

weixin_29197835的博客 143

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

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

风声的专栏 605

手把手教你用ESP32驱动MAX30102心率血氧传感器(含完整代码)

本文详细介绍了如何使用ESP32微控制器驱动MAX30102心率血氧传感器,构建智能健康监测系统。内容涵盖PPG原理、硬件连接、驱动配置、信号处理算法以及Web服务器数据可视化,提供完整代码实现,帮助开发者快速上手物联网健康设备开发。

weixin_29208077的博客 590

Rust LeetCode443 算法题解

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

weixin_43379230的博客 103

别再只调API了!深度拆解Dify文件上传的两种传参方式(sys.file vs. inputs.upload_file)

本文深度解析Dify平台文件上传的两种传参方式——sys.file与inputs.upload_file,详细对比其设计原理、技术实现及适用场景。通过代码示例和性能分析,帮助开发者在本地大模型应用中做出精准技术选型,提升文件处理效率与系统稳定性。

weixin_29063979的博客 268

MATLAB2022b安装

图文并茂,手把手教会你怎么安装MATLAB2022b

1万+

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

[小技巧] 如何复制知乎电子书中的文字和图片

文章目录一、背景二、复制文字1.最简单的方法(适合短小文字)2. 进阶方法(适合大段文字)三、复制图片四、注意事项 一、背景 有时候希望从书中摘录一部分文字作为笔记,但是知乎电子书阅读时候是禁止copy的,要么手打,要么OCR,给学习带来了一些不便。 审查元素后发现,知乎电子书是把文字分成一段一段的,试图F12直接copy不太方便。 本问将以谷歌Chrome浏览器为例,给出复制小技巧。 二、复制文字 1.最简单的方法(适合短小文字) 选中你需要的文字,左键单击不放,直接拖到地址栏。 然后可以从地址栏中

江南蜡笔小新 9251

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

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

wfly blog 312

遥感卫星影像AI数据集格式规范详解、技术原理与数据生产全流程技术手册

本技术手册旨在系统性地梳理遥感卫星影像AI数据集的各类格式标准(涵盖VOC、COCO、YOLO及遥感专用DOTA格式等),深入剖析其背后的技术原理,并详细阐述数据生产的全过程,涵盖预处理、标注、质量控制及数据增强等关键环节。无论您是刚入门的算法工程师,还是资深的数据生产管理者,本手册都将为您提供详实的参考与指引。

panshengwu的博客 1135

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

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

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

ZenovaEdgeOS的博客 558

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

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

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

olegja3d的博客 208

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

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

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

第 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的博客 299

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

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

2601_96785163的博客 285
上一篇: WASM 边缘推理:Rust + ONNX Runtime 的浏览器端模型部署实践
下一篇: AI 辅助 Rust 学习路径:从编译器报错到自主构建系统级工具的方法论
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论 3
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值