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

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

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

cover

一、异步编程的困惑:为什么 Rust 的 async 和其他语言不一样

从 Python 或 JavaScript 转到 Rust 的开发者,通常对 async/await 语法并不陌生。但 Rust 的异步模型有一个根本性差异:Rust 的 async 函数返回的是一个 Future,而不是立即开始执行。Future 是惰性的,必须有人来"驱动"它。

这个差异导致了很多困惑。你写了一个 async 函数,调用它,但什么都没发生。因为 Future 没有被 .await,也没有被 spawn 到运行时。Python 的 asyncio 会自动创建任务,JavaScript 的 Promise 会立即开始执行,而 Rust 要求你显式地决定 Future 何时何地执行。

这种设计不是 Rust 在为难开发者,而是出于零成本抽象的原则:你不为不使用的功能买单。如果你不需要异步运行时,就不需要引入它。但这也意味着,理解 Rust 异步编程必须从运行时的底层机制开始。

本文将深入 Tokio 运行时的调度机制,讲解 Future 的执行模型,并给出生产环境中的最佳实践。

二、Tokio 运行时的调度机制:从 Future 到操作系统事件循环

2.1 Future 的执行模型

Rust 的 Future 基于轮询(Poll)模型。每个 Future 有一个 poll 方法,运行时不断调用它来推进状态。poll 返回 Poll::Ready(T) 表示完成,返回 Poll::Pending 表示还没完成,需要等待。

flowchart TD
    A[Future 被 poll] --> B{当前状态}
    B -->|已完成| C[返回 Poll::Ready<br/>输出结果]
    B -->|未完成| D[注册 Waker 到事件循环]
    D --> E[返回 Poll::Pending]
    E --> F[运行时挂起该任务]
    F --> G[事件循环监听 I/O 事件]
    G -->|I/O 就绪| H[Waker 被唤醒]
    H --> A

2.2 Tokio 的两层调度

Tokio 运行时由两层调度器组成:

  • 工作窃取调度器(Work-Stealing Scheduler):多线程调度,用于常规任务。每个工作线程有自己的本地队列,空闲时从其他线程窃取任务。
  • 抢占式调度:为了防止某个任务长时间占用线程,Tokio 在每次 poll 结束时检查任务执行时间,超时则让出线程。

2.3 任务与 JoinHandle

tokio::spawn 将一个 Future 封装为任务(Task),提交到调度器。它返回一个 JoinHandle,可以用来等待任务完成或取消任务。

任务是最小的调度单位。一个任务内部可以有多个 .await 点,但从一个 .await 到下一个 .await 之间,任务不会被其他任务抢占(协作式调度)。这意味着,如果两个 .await 之间有长时间的计算,会阻塞整个工作线程。

三、生产级代码:Tokio 异步编程的最佳实践

3.1 运行时配置:按场景选择多线程还是单线程

use tokio::runtime::{Builder, Runtime};

/// 创建多线程运行时:适合 CPU 密集型 + I/O 密集型混合场景
fn create_multi_thread_runtime(worker_threads: usize) -> Runtime {
    Builder::new_multi_thread()
        .worker_threads(worker_threads)
        .thread_name("my-app-worker")
        // 启用所有线程的栈追踪,便于调试死锁
        .enable_all()
        .build()
        .expect("多线程运行时创建失败")
}

/// 创建单线程运行时:适合轻量级 CLI 工具
/// 单线程避免了多线程同步开销,启动更快
fn create_current_thread_runtime() -> Runtime {
    Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("单线程运行时创建失败")
}

fn main() {
    // CLI 工具用单线程即可
    let rt = create_current_thread_runtime();
    rt.block_on(async {
        // 应用逻辑
    });
}

3.2 spawn 与错误处理:不要让任务静默失败

use tokio::task::JoinError;
use std::time::Duration;

/// 安全地 spawn 任务:捕获 panic 和取消,避免静默失败
async fn spawn_safe_task() -> Result<String, JoinError> {
    let handle = tokio::spawn(async {
        // 模拟可能失败的工作
        let result = risky_operation().await;
        result
    });

    // 等待任务完成,处理 panic 和取消
    match handle.await {
        Ok(Ok(value)) => Ok(value),
        Ok(Err(_)) => Ok("任务内部错误,已降级处理".to_string()),
        Err(join_error) => {
            // 任务被取消或 panic
            if join_error.is_panic() {
                tracing::error!("任务发生 panic");
            }
            Err(join_error)
        }
    }
}

async fn risky_operation() -> Result<String, String> {
    // 模拟可能失败的操作
    Ok("操作成功".to_string())
}

3.3 长计算任务:用 spawn_blocking 避免阻塞事件循环

use tokio::task;

/// CPU 密集型计算:必须用 spawn_blocking,否则阻塞事件循环
async fn cpu_intensive_work(input: Vec<u8>) -> anyhow::Result<Vec<u8>> {
    // spawn_blocking 将任务放到专门的阻塞线程池
    // 不占用异步工作线程,不会影响其他任务的调度
    let result = task::spawn_blocking(move || {
        // 模拟 CPU 密集型计算:如压缩、加密、哈希
        let mut data = input;
        for byte in data.iter_mut() {
            *byte = byte.wrapping_add(1);
        }
        data
    })
    .await
    .map_err(|e| anyhow::anyhow!("计算任务失败: {}", e))?;

    Ok(result)
}

/// 带超时的异步操作:防止任务无限等待
async fn fetch_with_timeout(url: &str) -> anyhow::Result<String> {
    let result = tokio::time::timeout(
        Duration::from_secs(10),
        reqwest::get(url).and_then(|resp| resp.text()),
    )
    .await
    .map_err(|_| anyhow::anyhow!("请求超时: {}", url))??;

    Ok(result)
}

3.4 并发控制:用 Semaphore 限制资源使用

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

/// 并发下载器:限制同时进行的请求数量
struct ConcurrencyLimiter {
    semaphore: Arc<Semaphore>,
}

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

    /// 执行受限并发的任务:超过限制的请求会排队等待
    async fn run<F, T>(&self, task: F) -> anyhow::Result<T>
    where
        F: Future<Output = anyhow::Result<T>>,
    {
        // 获取信号量许可,如果没有可用许可则等待
        let permit = self.semaphore.acquire().await
            .map_err(|_| anyhow::anyhow!("信号量已关闭"))?;

        let result = task.await;

        // permit 在此处 drop,释放信号量许可
        drop(permit);

        result
    }
}

use std::future::Future;

/// 批量并发下载:限制最大并发数
async fn batch_fetch(urls: Vec<String>, max_concurrent: usize) -> Vec<anyhow::Result<String>> {
    let limiter = Arc::new(ConcurrencyLimiter::new(max_concurrent));
    let mut handles = Vec::new();

    for url in urls {
        let limiter = limiter.clone();
        let handle = tokio::spawn(async move {
            limiter.run(fetch_with_timeout(&url)).await
        });
        handles.push(handle);
    }

    let mut results = Vec::new();
    for handle in handles {
        match handle.await {
            Ok(result) => results.push(result),
            Err(e) => results.push(Err(anyhow::anyhow!("任务异常: {}", e))),
        }
    }
    results
}

3.5 优雅关闭:确保任务完成后再退出

use tokio::signal;
use tokio::sync::broadcast;

/// 优雅关闭模式:监听 Ctrl+C,通知所有任务退出
async fn graceful_shutdown() {
    let (shutdown_tx, _) = broadcast::channel::<()>(1);

    // 启动工作任务,每个任务持有 shutdown_rx
    for i in 0..3 {
        let mut shutdown_rx = shutdown_tx.subscribe();
        tokio::spawn(async move {
            loop {
                tokio::select! {
                    // 正常工作逻辑
                    _ = do_work(i) => {}
                    // 收到关闭信号,优雅退出
                    _ = shutdown_rx.recv() => {
                        tracing::info!("任务 {} 收到关闭信号,正在清理", i);
                        break;
                    }
                }
            }
        });
    }

    // 等待 Ctrl+C
    signal::ctrl_c()
        .await
        .expect("监听 Ctrl+C 失败");

    tracing::info!("收到关闭信号,通知所有任务退出");
    // 广播关闭信号
    let _ = shutdown_tx.send(());

    // 给任务一些时间完成清理
    tokio::time::sleep(Duration::from_secs(2)).await;
}

async fn do_work(id: usize) {
    tokio::time::sleep(Duration::from_millis(500)).await;
}

四、Tokio 异步编程的代价:调试难度、内存开销与生态碎片化

4.1 调试困难

异步代码的调用栈和同步代码完全不同。一个 .await 点会将函数的状态保存到堆上的状态机中,传统的调试器很难追踪。当任务卡住时,你看到的调用栈可能只有 tokio::runtime::scheduler 的内部帧,看不到业务逻辑。

缓解策略:使用 tokio-console 实时监控任务状态,使用 tracing 在关键节点打日志,使用 tokio::task::yield_now() 主动让出控制权来排查调度问题。

4.2 内存开销

每个 spawn 的任务都需要在堆上分配状态机。状态机的大小取决于 async 函数中跨 .await 存活的变量。如果一个 async 函数在 .await 前创建了大的缓冲区,这个缓冲区会被保存在状态机中,直到下一个 .await 才释放。

建议:在 .await 前显式 drop 不再需要的大变量,减少状态机体积。

4.3 Send 约束的困扰

tokio::spawn 要求 Future 满足 Send trait。如果 async 函数中跨 .await 持有了非 Send 的类型(如 Rc、RefCell),编译器会报错。这是初学者最常遇到的问题之一。

解决方案:将非 Send 的类型限制在 .await 之间使用,不要跨 .await 持有。或者用 spawn_local 替代 spawn(仅限单线程运行时)。

4.4 生态碎片化

Rust 异步生态存在运行时分裂:Tokio、async-std、smol 各自为政。很多库只支持特定运行时,混用会导致编译错误或运行时问题。选择 Tokio 作为默认运行时是最安全的选择,因为它的生态最完善。

五、总结

Rust 的异步编程基于轮询模型,Future 是惰性的,必须由运行时驱动。Tokio 是当前最成熟的异步运行时,提供了工作窃取调度器、任务管理和 I/O 驱动。

落地路线建议:

  1. CLI 工具用单线程运行时,服务端程序用多线程运行时
  2. CPU 密集型任务用 spawn_blocking,不要在 async 函数中直接计算
  3. 用 Semaphore 控制并发上限,防止资源耗尽
  4. 用 tokio-console 和 tracing 辅助调试异步问题
  5. 统一使用 Tokio 运行时,避免混用不同运行时的库

异步编程不是万能的。如果你的场景是纯 CPU 计算,同步代码可能更简单、更快。异步的价值在于 I/O 密集型场景,让程序在等待 I/O 时不浪费 CPU 时间。

Robot Framework 7.0 报告解析 本文深入解析 Robot Framework 7.0 新增的 JSON 报告功能,手把手教你如何从 output.xml 转换为结构清晰的 output.json,并通过 Python 脚本提取关键测试指标。文章附完整示例、命令、解析脚本,支持导出为 CSV 和 Markdown,方便接入可视化看板、群通知和 CI 流程。适用于测试自动化、质量平台建设和回归趋势分析场景。 阅读详情

相关推荐

微信小程序 | 小程序开发

事实上,目前小程序在我们生活中已经随处可见(特别是这次疫情的推动,不管是什么岗位、什么年龄阶段的人,到哪都需要打开健康码)WePY是由腾讯开源的,一款让小程序支持组件化开发的框架,通过预编译的手段让开发者可以选择自己喜欢的开发风格去开发小程序。Mpvue是一个使用Vue开发小程序的前端框架,也是 支持 微信小程序、百度智能小程序,头条小程序 和 支付宝小程序;微信小程序、支付宝小程序、淘宝小程序、抖音小程序、头条小程序、QQ小程序、美团小程序等。,其他平台的小程序往往是平台本身的一些公司或者顺手开发的。

CoderHing的博客~ 1万+

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

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

HeiquanMama的博客 1000

SpringBoot+Vue实现图片上传

SpringBoot+Vue实现图片上传

叶♥璃 2736

rust: Fan-out/Fan-in Pattern

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

Geovin Du Dream Park 159

HDR标准核心参数全解析:从PQ/HLG到元数据,一篇搞懂技术选型

本文全面解析HDR标准的核心参数,包括PQ/HLG传输函数和元数据机制,帮助读者理解技术选型的关键因素。通过对比主流HDR标准的技术细节,提供从内容创作到硬件适配的实用指南,助力实现更真实的视觉体验。

weixin_31766003的博客 301

【数据集】中国2003年至2022年全天空每日气温数据集

中国2003年至2022年全天空每日气温数据集

WW、forever的博客 604

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

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

qq_36765170的博客 569

2023华为OD面试手撕真题【最长公共前缀】

2023华为OD面试手撕真题【最长公共前缀】

MISAYAONE的博客 5244

Rust组织管理(AI回答)

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

yaoct的博客 153

家用扫地机器人实物拆解报告-从顶盖到每一颗螺丝 · 逐层拆解旗舰扫拖一体机器人

2026年旗舰扫拖机器人拆解报告:采用D形机身设计,主机重4.5kg,基站重12kg。核心配置包括RK3588S+STM32H743双处理器、8颗21700电池、LDS激光雷达和双摄像头+结构光导航系统。创新设计亮点:锥形滚刷自动排毛发、活水循环拖地系统、基站集成450W强力集尘和自动上下水模块(带三重防漏保护)。整机采用模块化设计,关键部件均支持快速更换,在密封性、防呆设计和降本增效方面展现出成熟的工程智慧。

智能硬件研发,欢迎交流 522

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

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

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

风声的专栏 605

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

Rust LeetCode443 算法题解

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

weixin_43379230的博客 103

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

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 315

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如何实现微服务网关的高并发与限流熔断机制

在现代互联网系统中,微服务架构已成为主流,而微服务网关则是整个系统的重要组成部分。当面对高并发、高可用性需求时,很多开发者对如何用 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

Rust 1.100 的 DropGuard:用 Python 实测失败回滚与吞异常

解析一批数据往列表里塞,塞到第三条抛异常,列表已经脏了一半——这类「能跑但结果不对」的 bug 不报错也不崩溃。Rust 1.100.0 把 core::mem::DropGuard 稳定了:包裹一个

aifannihao的博客 221

rust: Push & Pull Pattern

本项目基于Rust实现珠宝行业全流程的推-拉(Push&Pull)消息模式,采用领域驱动设计(DDD)六层架构。通过JewelryPushPullHub通道实现生产者推送与消费者拉取解耦,12个业务部门(如采购、设计、质检等)作为独立消费者,按供应链顺序串行或并发处理消息。系统集成重试熔断、线程安全日志(按日期/等级分文件)、内存仓储及依赖注入容器,确保高并发下流程可追溯、弹性可靠。演示涵盖串行调度、批量并发、端口契约调用等场景,完整呈现企业级消息型模式的核心能力。

Geovin Du Dream Park 107

我用 RustyPaste 做 AI Agent 云端存储

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

藏云阁技术社区 240

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

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

weixin_63115449的博客 183

Cursor + IntelliJ IDEA = OpenIDEA?这个Rust开源IDE有点东西

是一个开源的集成开发环境(IDE),设计目标是在保留 IntelliJ IDEA 优秀开发体验的同时,通过原生架构实现更高性能、更低资源占用和更开放的生态。OpenIDEA 项目仍然处于快速发展阶段,插件生态和语言支持成熟度暂时还无法与 JetBrains 系列相比,暂时不建议立即替代生产环境。

Tony.Dong的专栏 453
上一篇: WebAssembly AI 插件开发:浏览器端推理,从模型加载到推理流水线
下一篇: AI 驱动 Rust 编程:智能 Agent 辅助开发,从代码生成到自动化重构
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值