Tokio 任务调度机制:从 runtime 初始化到任务窃取

Rust之异步框架Tokio 介绍了Rust生态中核心的异步运行时框架Tokio,采用三层架构设计:核心层提供任务调度、I/O驱动和定时器;中间层封装网络、文件等异步API;应用层提供开发工具;并详细介绍了其调度原理,特别是Task队列操作;以及常用接口:任务管理、同步原语、网络与IO,以及定时器等 阅读详情

Tokio 任务调度机制:从 runtime 初始化到任务窃取

cover

一、异步运行时到底在调度什么

我刚开始学 Tokio 的时候,以为 tokio::spawn 就是开个线程。后来发现完全不是——Tokio 的任务调度和操作系统线程调度是两套机制。一个 Tokio 任务(Future)比线程轻得多,4GB 内存可以跑几百万个任务,但只能跑几千个线程。

理解 Tokio 调度的关键是分清三层模型:操作系统线程(Worker Thread)→ Tokio 任务(Green Task)→ Future 状态机。Worker Thread 是真正执行代码的载体,Green Task 是 Tokio 调度的单位,Future 是编译器生成的状态机。一个 Worker Thread 可以执行成千上万个 Green Task,通过协作式调度在任务间切换。

协作式调度的意思是:任务主动让出执行权(在 .await 点),而不是被抢占。这带来一个重要推论——如果一个 Future 在 .await 之间做了大量 CPU 密集计算,会阻塞整个 Worker Thread,其他任务无法执行。

二、Tokio 调度的底层机制:工作窃取与任务队列

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

flowchart TB
    A[tokio::spawn<br/>提交新任务] --> B[当前 Worker<br/>本地队列]

    B --> C[Worker 1<br/>本地队列: T1, T2, T3]
    D[Worker 2<br/>本地队列: T4, T5] --> E[Worker 2 执行 T4]
    F[Worker 3<br/>本地队列: 空] --> G[Worker 3 空闲]

    G -->|工作窃取| C
    G --> H[窃取 T1<br/>从队列尾部取]

    subgraph 调度策略
        I[本地优先<br/>无锁访问本地队列]
        J[窃取时从尾部取<br/>减少竞争]
        K[全局队列作为后备<br/>防止饥饿]
    end

    I --> C
    J --> H
    K --> L[全局队列<br/>注入任务]

    subgraph 阻塞处理
        M[阻塞操作<br/>如文件IO/同步锁]
        N[释放 Worker Thread]
        O[创建替代 Worker]
    end

    M --> N --> O

工作窃取的优势是负载均衡——忙的 Worker 不会闲着,闲的 Worker 会主动找活干。但窃取操作需要跨线程访问队列,有锁竞争开销。Tokio 的优化是:本地队列用无锁的 deque 实现,只有窃取时才需要原子操作,本地操作完全无锁。

三、生产级代码实现:Tokio 任务调度实践

3.1 Runtime 初始化与配置

use tokio::runtime::Runtime;
use std::time::Duration;

/// 创建自定义 Runtime
fn create_runtime() -> Runtime {
    // 为什么需要自定义 Runtime:默认 Runtime
    // 的 Worker 数量等于 CPU 核心数,
    // 但有些场景需要调整:
    // - CPU 密集型任务:Worker 数 = 核心数
    // - IO 密集型任务:Worker 数 = 核心数 * 2
    // - 混合型:保持默认即可
    tokio::runtime::Builder::new_multi_thread()
        .worker_threads(4)
        // 启用 IO 驱动(epoll/kqueue)
        .enable_io()
        // 启用时间驱动
        .enable_time()
        // 线程名称前缀,方便调试
        .thread_name("my-app-worker")
        // 线程栈大小,默认 2MB
        // 为什么可能需要调大:默认 2MB 对
        // 大多数异步任务足够,但如果
        // 在异步上下文中调用了
        // 同步的 C 库(通过 FFI),
        // 可能需要更大的栈
        .thread_stack_size(3 * 1024 * 1024)
        // 全局队列间隔
        // 为什么设为 61:Tokio 默认值,
        // 每 61 次本地调度后检查一次
        // 全局队列,防止全局队列中的
        // 任务饥饿
        .global_queue_interval(61)
        // 事件循环 tick 超时
        .event_interval(61)
        .build()
        .expect("Runtime 创建失败")
}

/// 创建轻量级单线程 Runtime
fn create_current_thread_runtime() -> Runtime {
    // 为什么用单线程 Runtime:
    // 1. 不需要并发,如 CLI 工具
    // 2. 避免多线程开销,如测试环境
    // 3. 确定性行为,如单元测试
    tokio::runtime::Builder::new_current_thread()
        .enable_io()
        .enable_time()
        .build()
        .expect("单线程 Runtime 创建失败")
}

3.2 任务调度与并发控制

use tokio::sync::Semaphore;
use std::sync::Arc;

/// 并发任务调度器
struct TaskScheduler {
    // 信号量控制最大并发数
    // 为什么用 Semaphore 而非固定数量
    // 的 spawn:Semaphore 允许任务
    // 完成后自动释放配额,新任务
    // 可以立即开始;固定 spawn 数量
    // 需要手动管理任务完成通知
    semaphore: Arc<Semaphore>,
    max_concurrency: usize,
}

impl TaskScheduler {
    fn new(max_concurrency: usize) -> Self {
        Self {
            semaphore: Arc::new(
                Semaphore::new(max_concurrency)),
            max_concurrency,
        }
    }

    /// 提交任务,受信号量控制
    async fn submit<F, T>(&self, task: F)
        -> tokio::task::JoinHandle<T>
    where
        F: Future<Output = T> + Send + 'static,
        T: Send + 'static,
    {
        let permit = self.semaphore.clone()
            .acquire_owned()
            .await
            .expect("信号量已关闭");

        tokio::spawn(async move {
            // permit 在任务完成后自动释放
            // 为什么用 acquire_owned:返回
            // OwnedSemaphorePermit,它
            // 实现了 Drop,任务完成时
            // 自动释放,不需要手动调用 forget
            let result = task.await;
            drop(permit); // 显式释放,更清晰
            result
        })
    }

    /// 批量执行任务,等待全部完成
    async fn batch<F, T>(
        &self,
        tasks: Vec<F>,
    ) -> Vec<T>
    where
        F: Future<Output = T> + Send + 'static,
        T: Send + 'static,
    {
        let handles: Vec<_> = tasks
            .into_iter()
            .map(|task| self.submit(task))
            .collect();

        // 等待所有任务完成
        // 为什么用 join_all 而非逐个 await:
        // join_all 同时等待所有 Future,
        // 不会因为某个慢任务阻塞其他
        // 任务的完成通知
        let results = futures::future::join_all(handles)
            .await;

        // 收集结果,忽略 panic 的任务
        results
            .into_iter()
            .filter_map(|r| r.ok())
            .collect()
    }
}

3.3 阻塞任务的处理

use tokio::task;

/// 阻塞操作的正确处理方式
async fn handle_blocking_operations() {
    // ❌ 错误:在异步上下文中执行阻塞操作
    // async fn bad_example() {
    //     // 这会阻塞 Worker Thread!
    //     // 其他任务无法执行
    //     std::thread::sleep(Duration::from_secs(5));
    //     let data = std::fs::read_to_string("big.txt").unwrap();
    // }

    // ✅ 正确:使用 spawn_blocking
    // 为什么用 spawn_blocking:
    // 它把阻塞操作放到专门的阻塞线程池,
    // 不占用异步 Worker Thread;
    // 阻塞线程池的线程数默认 512,
    // 远大于 Worker 数量
    let file_content = task::spawn_blocking(|| {
        // 这里的代码在阻塞线程池执行
        std::fs::read_to_string("big.txt")
            .expect("文件读取失败")
    }).await.expect("任务执行失败");

    println!("文件内容长度: {} 字节",
             file_content.len());

    // ✅ CPU 密集计算也应该用 spawn_blocking
    let result = task::spawn_blocking(|| {
        let mut sum: u64 = 0;
        for i in 0..1_000_000_000 {
            sum = sum.wrapping_add(i);
        }
        sum
    }).await.expect("计算任务执行失败");

    println!("计算结果: {}", result);
}

/// 阻塞线程池大小配置
fn configure_blocking_pool() {
    let runtime = tokio::runtime::Builder
        ::new_multi_thread()
        .worker_threads(4)
        // 最大阻塞线程数
        // 为什么设为 64 而非默认 512:
        // 如果阻塞操作涉及文件 IO,
        // 512 个线程可能导致文件描述符
        // 耗尽;64 是一个安全的上限
        .max_blocking_threads(64)
        .build()
        .expect("Runtime 创建失败");
}

四、Tokio 调度的边界:不适合的场景与替代方案

CPU 密集型计算:Tokio 的设计假设任务是 IO 密集型的,.await 点之间应该很快完成。如果你的任务需要大量 CPU 计算,即使放在 spawn_blocking 里,阻塞线程池也会成为瓶颈。此时应该用 Rayon 这样的数据并行库,或者用 channel 把任务分发给独立的计算线程。

需要精确调度的实时系统:Tokio 的调度是非确定性的——任务执行顺序取决于工作窃取和 IO 事件到达顺序。如果你的系统需要精确的任务调度顺序(如实时音视频处理),Tokio 不是合适的选择。

极低延迟场景:Tokio 的任务调度有微秒级开销。对于纳秒级延迟要求的场景(如高频交易),这个开销不可接受。此时应该用无锁数据结构和 busy-loop 轮询。

与同步代码的互操作:如果你的项目大量依赖同步库(如 diesel 的同步数据库驱动),在异步上下文中调用它们会阻塞 Worker Thread。spawn_blocking 可以缓解,但会增加线程切换开销。长期方案是迁移到异步驱动。

五、总结

Tokio 的任务调度基于工作窃取算法,每个 Worker Thread 有本地队列,空闲 Worker 从其他 Worker 窃取任务。理解调度的关键是三个层次:Worker Thread 是执行载体,Green Task 是调度单位,Future 是状态机。协作式调度意味着任务在 .await 点让出执行权,长时间计算会阻塞 Worker。阻塞操作必须用 spawn_blocking 放到专门的线程池。并发控制用 Semaphore,批量执行用 join_all。CPU 密集型任务不适合 Tokio,应该用 Rayon 或独立线程。

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

相关推荐

使用OpenCV进行3D重建:详细指南

3D重建是计算机视觉领域的一项关键技术,它能够从二维图像中恢复出场景的三维结构。这项技术在机器人视觉、增强现实和3D建模等多个领域都有广泛的应用。在本篇技术博客中,我们将详细介绍如何使用OpenCV这一流行的计算机视觉库来实现3D重建。我们将逐步探讨整个过程,包括相机标定、特征点提取与匹配、立体校正、深度图计算以及最终的三维重建。3D重建是一个复杂的过程,涉及多个步骤和多种算法。OpenCV提供了强大的工具来支持这一过程,从相机标定到特征点提取与匹配,再到立体校正和深度图计算,最后实现三维重建。

weixin_41544125的博客 1321

Tokio 多线程调度器架构的深度解读

Tokio 的多线程调度器是一台复杂的“事件协调器”——在各种任务、IO、定时器、阻塞兼容之间精确调度,实现最大化的并发。掌握其架构与行为,对写出高性能异步代码至关重要。通过理解队列结构、工作窃取、IO 驱动和阻塞策略,你可以更有信心地调校 runtime、识别瓶颈,并构建出既高效又稳定的 Rust 服务。

qq_43221686的博客 2079

富芮坤FR801xH蓝牙协议栈启动流程和notify实现温度数据主动上传

文章目录一、蓝牙协议栈启动流程1.1 初始化代码1.2 初始化流程1.3 回调函数里的初始化二、notify实现2.1 notify介绍2.2 notify实现2.3.1 定义数据2.3.2 获取连接号conidx2.3.3 gatt_notification函数的使用三、notify温度上传测试3.1 蓝牙调试工具3.2 蓝牙调试器设置3.3 测试结果四、参考链接   基于sdk开发的好处是方便项目的快速落地,现在用的是SDK里面的源文件,目前只是学习FR801xH芯片的特性,裁剪这个SDK需要点时间,

weixin_43810563的博客 4322

【Rust 探索之旅】Tokio 异步运行时完全指南:深入理解 Rust 异步编程与源码实现

在处理高并发场景时,我深刻体会到异步编程的威力。我们的大数据处理项目迁移到 Tokio 后,在相同硬件下吞吐量提升了 3 倍,P99 延迟降低了 60%。Tokio 不仅是 Rust 生态中最重要的异步运行时,更是现代高性能系统的基石。本文将深入 Tokio 源码,从 Runtime 调度器到 I/O 驱动器,从定时器系统到任务管理,全面剖析其设计精髓。我将结合实际项目经验,通过大量代码示例和真实案例,帮助你理解 Tokio 的工作原理。

白鹿第一帅的 优快云 博客 2567

SAP HANA Studio保姆级教程:从零开始连接S/4 HANA数据库(含权限配置避坑指南)

本文提供SAP HANA Studio从零开始连接S/4 HANA数据库的保姆级教程,涵盖安装配置、权限管理及高效查询技巧。特别针对SAP S/4 HANA数据库底表查询的常见问题提供解决方案,帮助开发者和业务分析师快速掌握HANA数据库运维管理核心技能。

weixin_29268331的博客 295

深入解析mSATA与mini-PCIE接口的硬件设计要点

本文深入解析mSATA与mini-PCIE接口的硬件设计要点,涵盖信号定义、电源设计、高速信号处理及PCB布局布线等关键内容。通过实战案例和调试技巧,帮助工程师规避常见设计陷阱,提升电路设计效率,特别适合工业控制和嵌入式系统开发场景。

weixin_28741413的博客 319

Rust 异步运行时(Runtime)深度解析:`Tokio` 的多线程调度器、`Waker` 与 I/O 事件循环

本文深度解析了Tokio异步运行时的核心机制:1)多线程工作窃取调度器实现高效任务调度,每个工作线程维护本地队列并通过窃取机制实现负载均衡;2)I/O驱动器(mio)整合epoll/kqueue等系统调用,通过Waker机制将I/O事件与任务唤醒无缝连接;3)#[tokio::main]宏构建运行时环境,作为同步与异步世界的桥梁。Tokio通过这三层架构,将Future状态机、CPU调度与I/O事件处理有机结合,形成高性能异步生态系统的核心引擎。

AtomicVerse的博客 844

PowerDesigner16.5下载和安装教程

一、软件下载 1.下载地址(不用复制,直接点击下载链接即可):链接:https://pan.baidu.com/s/1MSnWHWt3SO2Uz5dt9AANAg提取码:z9kk 二、软件安装 1.下载安装包(包含安装文件、汉化包、注册文件) 2.下载后文件内容如下 3....

cicong2374的博客 10万+

Rust异步IO:ncspot网络请求处理机制全景分析

你是否曾好奇,一个基于ncurses的终端应用如何流畅处理Spotify的海量音乐数据流?ncspot作为一款用Rust编写的跨平台Spotify客户端,面临着终端UI渲染与网络请求处理的双重挑战。本文将深入剖析其异步IO架构,揭示如何通过Tokio运行时、事件驱动设计和精心优化的任务调度,实现终端环境下的高效网络通信。 读完本文你将掌握: - Rust异步运行时在终端应用中的实战配置 - 事件...

gitblog_00099的博客 1111

【WRF运行报错】总结WRF运行时报错及解决方案(持续更新)

总结WRF运行时报错及解决方案(持续更新)

WW、forever的博客 1634

AMBA-CHI协议详解(二)

读事务,写事务,原子事务,Stash事务,Dataless事务,DVM事务,Retry事务。

Crazzy_M的博客 6660

高性能axum:Tokio运行时并发模型最佳实践

你是否还在为axum应用的并发性能瓶颈发愁?默认配置下的Tokio运行时常常无法充分利用多核资源,导致高并发场景下响应延迟飙升。本文将通过3个核心配置参数的优化,帮助你实现QPS提升40%的性能突破。读完本文你将掌握:axum并发模型底层逻辑、5种运行时调优参数、生产级配置模板以及压测验证方法。 ## axum与Tokio的协作机制 axum作为基于Tokio、Tower和Hyper构建的We...

gitblog_00737的博客 477

【APM】在Kubernetes中搭建OpenTelemetry+Loki+Tempo+Grafana链路追踪(实战一,Loki日志中查看链路追踪数据)

这对于那些不能直接控制 JVM 启动参数的应用特别有用,比如通过 JNI (Java Native Interface) 调用 JVM 的应用、脚本中嵌入的 JVM 应用,或者一些服务管理工具自动启动的服务。这为用户提供了一个灵活的架构,可以根据需要选择最适合自己的追踪解决方案,或者根据环境(如开发、测试、生产)的不同配置不同的后端。: OpenTelemetry SDK 提供了丰富的特性,如自动追踪上下文传播、手动追踪跨度的创建与关联、标签和事件的添加等,使得追踪数据更加丰富和有用。

CN_Eden 3245

rust语言AI编程学习笔记(一)Tokio库(异步编程)

Tokio 是 Rust 的异步运行时,专为 IO 密集型任务设计。其核心采用反应器-执行器模型,通过轻量级任务实现高并发。主要特性包括:1) #[tokio::main]宏作为入口,支持多线程或单线程模式;2) tokio::spawn创建并发任务;3) join!并行等待多个任务;4) select!选择最先完成的任务;5) JoinSet管理动态任务组。共享状态通过异步锁(Mutex/RwLock)实现线程安全。Tokio 优势在于高效利用系统资源,特别适合网络服务等场景,但对纯CPU计算任务建议使用

咸甜适中 437

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

Mold 2.4.1致命漏洞:Tokio运行时嵌套导致的线程崩溃深度剖析

你是否在使用Mold 2.4.1链接器构建Rust项目时遇到神秘的线程崩溃?当Tokio运行时遭遇Mold的多线程链接机制,可能引发难以调试的嵌套运行时冲突。本文将从技术原理到解决方案,全面解析这一隐藏在现代链接器与异步运行时交互中的致命陷阱。 ## 问题现象:从一次CI失败说起 某互联网公司的Rust微服务在升级Mold 2.4.1后,CI流水线频繁出现**间歇性线程崩溃**。错误日志显示`...

gitblog_00472的博客 399

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

深入Rust异步网络编程:从零剖析wtx库的事件驱动与IO多路复用

异步网络编程是现代高性能服务端开发的核心技术,其本质是通过事件驱动模型和IO多路复用机制实现高并发处理。在Rust生态中,异步编程基于Future抽象,通过Reactor模式监听IO事件,配合执行器驱动任务执行。这种架构的价值在于能够用少量线程处理大量并发连接,显著提升系统资源利用率。典型的应用场景包括Web服务器、实时通信系统和分布式中间件。本文以教学项目wtx为例,深入解析其如何手工封装epoll/kqueue系统调用,实现精简的事件循环和Future执行器,帮助开发者从底层理解Rust异步网络库的工作

weixin_34008805的博客 291

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

rust: Fan-out/Fan-in Pattern

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

Geovin Du Dream Park 159

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

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

qq_36765170的博客 569

Rust组织管理(AI回答)

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

yaoct的博客 153

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

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

风声的专栏 605

Rust LeetCode443 算法题解

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

weixin_43379230的博客 103

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

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

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

wfly blog 319

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 借用检查器深入理解:从编译错误到所有权心智模型
下一篇: WASM AI 推理性能优化:浏览器端模型推理的工程实践
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论 3
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值