Python 异步编程对比 Rust:从 asyncio 到 Tokio 的思维迁移

Python asyncio 入门:从伪异步到真正高并发的实战指南 asyncio 是 Python 实现高并发 I/O 密集型任务的核心机制,其本质是基于单线程事件循环的协作式调度系统,通过协程让渡(await)实现毫秒级多路复用。它不改变 CPU 执行模型,但彻底重构了 IO 等待期间的资源利用逻辑——当网络请求阻塞时,CPU 可立即切换处理其他就绪任务,从而将服务器并发能力从千级线程提升至十万级连接。技术价值在于极低的内存开销与确定性的调度延迟,广泛应用于 Web 服务(如 FastAPI)、爬虫、实时通信和微服务网关等场景。本文聚焦 asyncio 的真实落地,直击 阅读详情

Python 异步编程对比 Rust:从 asyncio 到 Tokio 的思维迁移

cover

一、学 Rust 异步之前,先搞清楚 Python 异步到底在干什么

我写 Python 异步快两年了,asyncio 用得很熟,但说实话一直没完全理解事件循环的底层机制——直到学了 Rust 的 Future 和 Tokio,回头看 Python 的 asyncio 才豁然开朗。两种语言的异步模型有本质区别:Python 的协程是单线程协作式调度,Rust 的 Future 是零成本抽象的状态机。

这篇文章不是"Python vs Rust 谁更好",而是通过对比两种异步模型的底层机制,帮助理解异步编程的本质。如果你也像我一样用 Python 异步很熟但"知其然不知其所以然",这篇可能会有帮助。

二、Python asyncio 与 Rust Tokio 的模型对比

flowchart LR
    subgraph Python asyncio
        A1[async def 协程] --> A2[事件循环<br/>单线程]
        A2 --> A3[协程调度<br/>协作式让出]
        A3 --> A4[await 挂起<br/>注册回调]
        A4 --> A5[IO 就绪<br/>恢复协程]
    end

    subgraph Rust Tokio
        B1[async fn Future] --> B2[工作窃取调度器<br/>多线程]
        B2 --> B3[任务调度<br/>Poll 驱动]
        B3 --> B4[Pending 挂起<br/>注册 Waker]
        B4 --> B5[IO 就绪<br/>Waker 唤醒]
    end

    A1 -.->|生成器实现| A2
    B1 -.->|状态机实现| B2

    style A2 fill:#fff3e0
    style B2 fill:#e3f2fd

Python asyncio 的核心是单线程事件循环 + 协程协作式调度。async def 是生成器语法糖,await 是 yield 的语义。Rust Tokio 的核心是多线程工作窃取调度器 + Future 的 Poll 模型。async fn 是状态机变换,await 是状态转换点。两者的根本区别在于:Python 的协程是运行时对象(有堆分配),Rust 的 Future 是编译期变换(零成本抽象)。

三、代码实现与分析

3.1 Python asyncio 底层机制

import asyncio
import time
from typing import Generator


# Python 协程的本质:生成器
# async def fetch(url):
#     response = await aiohttp.get(url)
#     return response
#
# 等价于:
class Coroutine:
    """简化版协程实现,理解 asyncio 底层"""

    def __await__(self):
        return (yield self)


class AsyncSleep:
    """模拟 asyncio.sleep 的底层实现"""

    def __init__(self, seconds: float):
        self.seconds = seconds

    def __await__(self):
        # yield 让出控制权给事件循环
        # 事件循环在指定时间后 send() 恢复协程
        yield self  # 把自己交给事件循环
        return None


class SimpleEventLoop:
    """简化版事件循环,理解 asyncio.run 的底层"""

    def __init__(self):
        self._ready = []
        self._scheduled = []

    def create_task(self, coro):
        """创建任务"""
        task = Task(coro)
        self._ready.append(task)
        return task

    def run_until_complete(self, coro):
        """运行直到所有任务完成"""
        main_task = Task(coro)
        self._ready.append(main_task)

        while self._ready or self._scheduled:
            # 处理就绪队列
            while self._ready:
                task = self._ready.pop(0)
                task.step()

            # 检查定时器
            now = time.monotonic()
            while self._scheduled and self._scheduled[0][0] <= now:
                _, task = self._scheduled.pop(0)
                self._ready.append(task)

            if self._scheduled and not self._ready:
                # 没有就绪任务,等待最近的定时器
                wait_time = self._scheduled[0][0] - now
                time.sleep(max(0, wait_time))


class Task:
    """简化版 Task"""

    def __init__(self, coro):
        self._coro = coro

    def step(self):
        """驱动协程执行一步"""
        try:
            result = self._coro.send(None)
            # result 是 await 的值(如 AsyncSleep 对象)
            if isinstance(result, AsyncSleep):
                # 注册定时器
                wake_time = time.monotonic() + result.seconds
                # 事件循环会在 wake_time 后重新 step() 这个 task
        except StopIteration as e:
            # 协程执行完毕
            pass


# 实际 asyncio 使用
async def python_async_example():
    """Python asyncio 的典型用法"""
    # 并发执行多个 IO 操作
    results = await asyncio.gather(
        fetch_data("api1"),
        fetch_data("api2"),
        fetch_data("api3"),
    )
    return results


async def fetch_data(name: str) -> str:
    await asyncio.sleep(0.1)  # 模拟 IO
    return f"data from {name}"

3.2 Rust Tokio 等价实现

use tokio::time::{sleep, Duration};
use tokio::join;

/// Rust Tokio 的等价实现
async fn rust_async_example() -> Vec<String> {
    // 并发执行多个 IO 操作
    let (r1, r2, r3) = join!(
        fetch_data("api1"),
        fetch_data("api2"),
        fetch_data("api3"),
    );
    vec![r1, r2, r3]
}

async fn fetch_data(name: &str) -> String {
    sleep(Duration::from_millis(100)).await;
    format!("data from {}", name)
}

/// 对比:Python 和 Rust 异步的关键差异
///
/// 1. 协程 vs Future
///    Python: async def 返回 coroutine 对象(堆分配)
///    Rust:   async fn 返回 Future trait 对象(状态机,栈友好)
///
/// 2. 调度模型
///    Python: 单线程事件循环,协程协作式调度
///    Rust:   多线程工作窃取调度器,任务可跨线程迁移
///
/// 3. 错误处理
///    Python: try/except,异常可以穿透 await
///    Rust:   Result<T, E>,错误必须显式处理
///
/// 4. 取消语义
///    Python: asyncio.Task.cancel() 抛 CancelledError
///    Rust:   drop(Future) 直接清理,无异常

3.3 思维迁移:Python 开发者学 Rust 异步的常见坑

use tokio::sync::Mutex as TokioMutex;
use std::sync::Mutex as StdMutex;
use tokio::task;

/// 坑1:以为 async fn 会自动在后台执行
async fn pitfall_auto_run() {
    // Python: asyncio.create_task() 会立即调度
    // Rust: async fn 只是定义,不会执行
    let future = fetch_data("api");  // 不会执行!
    future.await;                     // 这里才执行

    // 要并发执行,必须用 tokio::spawn
    let handle = tokio::spawn(fetch_data("api"));  // 提交到调度器
    handle.await.unwrap();  // 等待结果
}

/// 坑2:在异步代码中使用 std::sync::Mutex
async fn pitfall_std_mutex() {
    let mutex = StdMutex::new(0);

    // Python: asyncio 是单线程,不需要锁
    // Rust: Tokio 是多线程,但 std::sync::Mutex 持有锁跨 await 会死锁
    let mut guard = mutex.lock().unwrap();
    *guard += 1;
    // some_async_op().await;  // ❌ 持有 std::sync::Mutex 跨 await!
    drop(guard);  // ✅ 在 await 前释放

    // 或者用 tokio::sync::Mutex
    let async_mutex = TokioMutex::new(0);
    let mut guard = async_mutex.lock().await;
    *guard += 1;
    // some_async_op().await;  // ✅ tokio Mutex 可以跨 await
}

/// 坑3:以为 .await 会创建新线程
async fn pitfall_new_thread() {
    // Python: await 会让出控制权给事件循环
    // Rust: .await 只是状态机的一个状态转换点,不会创建线程
    // 当前任务在 .await 处挂起,调度器执行其他任务
    // 当 IO 就绪时,Waker 唤醒当前任务继续执行

    let result = fetch_data("api").await;
    // 这里仍在同一个工作线程上(除非被工作窃取迁移)
}

/// 坑4:忽略 Send 约束
async fn pitfall_send() {
    // Python: 所有对象都可以跨线程传递(GIL 保护)
    // Rust: tokio::spawn 要求 Future 是 Send
    // 如果 Future 中包含 !Send 的类型(如 Rc),编译报错

    use std::rc::Rc;
    let data = Rc::new(42);  // Rc 不是 Send

    // ❌ 编译错误:Rc<i32> cannot be sent between threads safely
    // tokio::spawn(async move {
    //     println!("{}", *data);
    // });

    // ✅ 用 Arc 替代 Rc
    use std::sync::Arc;
    let data = Arc::new(42);
    tokio::spawn(async move {
        println!("{}", *data);
    });
}

四、两种异步模型的权衡

Python asyncio 的优势:简单直观,单线程无数据竞争,生态成熟(aiohttp、asyncpg 等),适合 IO 密集型服务。劣势:单线程 CPU 密集任务会阻塞事件循环(需用 run_in_executor),GIL 限制真正的并行。

Rust Tokio 的优势:零成本抽象,多线程真正并行,编译期保证线程安全,适合高性能场景。劣势:学习曲线陡峭(Send/Sync、Pin、生命周期),生态不如 Python 成熟,调试异步代码更困难。

迁移建议:从 Python asyncio 迁移到 Rust Tokio 时,最大的思维转变是"从单线程协作式到多线程抢占式"。Python 中不需要考虑的线程安全问题(锁、Send/Sync)在 Rust 中是编译期强制检查的。建议先理解 Rust 的所有权和生命周期,再学 Tokio——异步是建立在所有权系统之上的。

五、总结

Python asyncio 和 Rust Tokio 的异步模型有本质区别:Python 是单线程协作式调度,Rust 是多线程 Poll 驱动。本文通过对比两者的底层机制,帮助理解异步编程的本质。关键差异为:Python 协程是运行时对象,Rust Future 是编译期状态机;Python 单线程无数据竞争,Rust 多线程需要 Send/Sync 保证;Python 用异常处理错误,Rust 用 Result 显式处理。从 Python 迁移到 Rust 异步,最大的挑战不是语法,而是思维模型——从"单线程无锁"到"多线程编译期安全"。

编程语言速度之争:从执行、并发到开发效率的多维分析 在计算机科学中,编程语言的性能评估是一个多维度的复杂问题,涉及执行速度、并发性能、开发效率等多个层面。从原理上看,编译型语言如C、Rust通过直接生成机器码获得接近硬件的执行效率,而解释型语言则依赖运行时环境进行动态优化。在技术价值层面,不同语言的设计哲学决定了其在不同场景下的适用性:C语言在系统编程和嵌入式领域具有不可替代的地位,Rust通过所有权系统实现了内存安全与高性能的平衡,Go语言则凭借轻量级协程模型在云原生领域大放异彩。从应用场景来看,高性能计算、高并发网络服务、快速原型开发等不同需求对应着不同 阅读详情

相关推荐

C语言模拟async/await:用宏与状态机实现异步编程

异步编程是现代软件开发中处理I/O密集型与高并发任务的核心范式,其本质在于通过非阻塞操作提升程序吞吐量与响应速度。从早期的回调函数到Promise模式,再到async/await语法糖,技术演进始终围绕提升代码可读性与可维护性展开。在系统级编程中,C语言虽未原生支持协程,但通过函数指针、宏和手动状态机,开发者可以构建轻量级的协作式任务调度器,模拟出高级语言的异步编程体验。这种技术方案尤其适用于嵌入式系统、网络服务器等对性能和可控性要求极高的场景,为C项目带来了更清晰的代码组织方式。本文将以状态机和宏为核心,

weixin_33938733的博客 356

从 Python asyncio 到 Rust Tokio:异步运行时的底层机制与实战对比

Python asyncio 和 Rust Tokio 虽然都使用语法,但底层调度模型截然不同:前者是单线程事件循环,后者是多线程工作窃取调度器。这种差异直接导致了 Rust 异步代码中Send约束和所有权问题的出现。从 asyncio 迁移到 Tokio 时,需要放弃"协程天然线程安全"的假设,转而用 Rust 的类型系统来保证并发正确性。对于 I/O 密集型、低并发场景,Python asyncio 仍然是高效的选择;

no1coder的博客 5653

C# async/await不是语法糖:异步编程底层原理与实战避坑

async/await是现代C#异步编程的核心机制,本质是编译器驱动的状态机契约,而非简化写法的语法糖。它通过解耦等待操作与线程绑定,实现I/O密集型任务的零线程挂起,显著降低上下文切换与内存开销。其技术价值在于统一抽象异步操作(如HTTP请求、串口读取、文件IO),支撑高并发上位机系统、无线温度监测等典型工业场景。结合Task状态机、SynchronizationContext捕获、ConfigureAwait控制执行上下文等关键能力,开发者可构建响应式、可伸缩且易维护的异步应用。本文深入剖析async/

weixin_34146805的博客 322

RustTraining 异步编程开篇:为什么 Rust 的 async/await 与其他语言截然不同

> **导读**:本文基于 RustTraining 仓库中的 [async-book](https://link.gitcode.com/i/0bf887ca0e9f7eafbea40390cc1ed29d) 第一章,系统讲解 Rust 异步模型最根本的差异——**Rust 没有内置异步运行时**,`async fn` 只是把函数编译成实现 `Future` trait 的状态机,需要由第三方执

gitblog_00094的博客 449

Qwen3-Coder:MoE架构与256K长上下文的代码理解新范式

大语言模型在代码理解任务中,正从单一Transformer架构向稀疏化、专业化方向演进。MoE(Mixture of Experts)作为一种动态路由的专家混合机制,通过按词法、语法、语义和惯用法划分专家模块,显著提升代码分析的精度与可解释性;而256K原生长上下文支持,则依托稀疏注意力与分层建模技术,突破传统O(n²)计算瓶颈,使模型具备项目级代码资产的整体认知能力。这种‘结构化专家调度+超长上下文感知’的技术组合,不仅降低了推理显存开销,更重塑了代码补全、审查与重构等核心开发场景的工程实践路径。Qwen

weixin_30598225的博客 414

AI浏览器本质:意图理解与语义交互范式重构

浏览器正从‘渲染网页’的工具演变为‘理解用户意图’的智能代理。其核心在于将自然语言输入转化为可执行的语义契约,依托本地向量库实现上下文感知,并通过可操作语义块完成端到端任务闭环。这一转变超越了大模型调用表象,直指人机交互范式升级——不再依赖关键词搜索与页面跳转,而是基于意图理解、动态上下文和细粒度交互实现信息主动适配。AI浏览器因此成为新一代数字工作流的基础设施,在电商比价、政务办事、学术研究等需多源协同与实时决策的场景中展现不可替代的技术价值。

weixin_30596735的博客 412

Rust Async/Await 速通指南:Future 模型、Tokio 运行时与并发陷阱实战(RustTraining 系列)

> 本文是 [Rust Patterns 训练书](https://link.gitcode.com/i/3e1960e8fc0be0e7b1bf413cb73a94dd) 第 16 章「Async/Await Essentials」的完整展开。核心围绕三个问题:Rust 的 `Future` 为何与 Go goroutine、Python asyncio 本质不同;如何用 Tokio 快速写出并

gitblog_01034的博客 336

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

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

yinghan2005的专栏 342

OmO 项目的 Python 异步开发规范:用 AnyIO 4.x 结构化并发全面替换 asyncio 惯用法

> 在 OmO 的 Python 技能栈中,`import asyncio` 是被明令禁止的:所有异步代码必须统一使用 `import anyio`(AnyIO 4.x)。这份指南以仓库内 [async-anyio.md](https://link.gitcode.com/i/a5a984ed3653772917d7ab7c3fd79075) 为骨架,系统讲解 Task Group、取消语义、超时

gitblog_00943的博客 688

【3D目标检测】激光雷达和相机联合标定(一)——ROS同步解包

激光雷达和相机联合标定(一)——ROS同步解包

qq_44703886的博客 4239

Look4sat蓝牙追星云台

//这是一个追星云台的小程序 //配合Look4sat蓝牙传输数据(W*** A***),并让电机做出动作 //app设置内填好ESP32的蓝牙MAC,数据格式:W$AZ A$EL //希望大家可以共同改进

HoyAnGx的博客 620

Python生态ASGI、WSGI库:Starlette、Twisted、Granian、Bjoern、Daphne、Waitress、Hypercorn、Cheroot、Meinheld

Python生态ASGI、WSGI、ASGI库:Starlette、Twisted、granian、Bjoern、Daphne、Waitress、Hypercorn、Cheroot、Meinheld

lonelymanontheway的博客 502

炉石传说游戏系统拆解和部分系统分析

一.游戏综述 《炉石传说:魔兽英雄传》是一款由暴雪娱乐公司出品的策略类卡牌游戏。中国大陆地区的独家运营由网易公司代理。2014年3月13日全球同步正式运营。游戏背景设定于暴雪的魔兽系列,共十位魔兽中的角色作为十种不同的职业。而玩家要做的,就是根据己方现有的卡牌组建合适的卡组,指挥英雄,驱动随从,施展法术,与游戏好友或素不相识的对手一决高下。 二.游戏系统拆解图 三.游戏系统部分分析 1. 对战系统 (1)战斗准备 炉石传说开始前都需要配置至少30张卡牌作为出战卡组 .....

Jimmy72236的博客 4927

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

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

qq_36765170的博客 571

ai数字人系统部署

这段代码实现了基本的语音交互闭环,用户通过语音输入问题,数字人识别语音后进行自然语言理解并生成回复,再将回复转换为语音输出。但实际应用中的 AI 数字人系统更为复杂,如形象渲染需专业图形引擎(如 Unity、Unreal Engine),自然语言处理也会涉及更复杂的模型微调及多轮对话管理等。一个完整的 AI 数字人系统涵盖形象生成、自然语言处理、动作控制等多个复杂功能,下面为你提供一个 Python 示例,整合多个库来实现数字人基础功能,包括语音交互、简单的自然语言理解以及通过虚拟形象展示对话。

weixin_ggwwsscc的博客 371

DELPHI11 利用Android手机实现条码扫描功能

好了,整个过程全部结束,当然这只是最简单的例子,只是演示一下如何识别条码,更多的条码处理功能,比如优化,提速等需要在后面继续。安装过程中所有提示框全部按OK就可以,直到提示安装成功,那么ZXing库就成功完成了安装。点击红框标识的文件夹图标,将下载的ZXing库文件路径加入进来后,点ADD。第三步:选择下载的ZXing库路径,并按Ctrl + A进行全选,并导入。至此为止,我们的库才算是全部安装完成,可以在DELPHI 中正常引用了。2.打开相机,识别条码,并将条码内容显示在MEMO1中。

1531

rust: Fan-out/Fan-in Pattern

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

Geovin Du Dream Park 162

Gazebo仿真环境下的强化学习实现

实际上利用Gazebo进行强化学习无非是环境获取上的不同,Gazebo的环境控制需要使用ROS服务进行控制,状态可以通过Gazebo进行获取,同时某些必要数据需要从话题中获取,最重要的是组织获取 的数据(通过话题等)与控制Gazebo的仿真步骤之间的组合。强化学习的手段与传统算法无异,强化学习方法最重要的是要确定动作空间、状态空间、奖励空间,这三个空间是work的前提。在笔者自己的环境中,将获取里程计的话题以及获取激光点的数据替换成为了自己的本机的仿真环境匹配的话题。

Moresweet 猫甜 6451

Rust组织管理(AI回答)

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

yaoct的博客 153

AHB2eflash 控制器设计笔记

① SRAM② DRAM③ SSD④ SATA⑤ U 盘⑥ 移动硬盘⑦ 机械磁盘eflash。

weixin_46220498的博客 3078

MATLAB和S7-1200PLC水箱液位高度PID控制联合仿真(KEPserverOPC通信应用)

SMART PLC 向导PID的详细介绍请查看下面文章链接:S7-200 SMART PLC PID向导详细介绍(如何实现P、PD、PID控制器)-优快云博客文章浏览阅读1k次。这篇博客主要介绍SMART PLC PID向导的使用,PID控制相关的其它内容请查看专栏系列文章,常用链接如下:SMART PLC PID负压控制(过程量为负数)_负压控制pid控制程序_RXXW_Dor的博客-优快云博客1、如何实现PID反作用调节?S7-1200PLC和KEPserver OPC通信-优快云博客。

RXXW_Dor的博客 1783

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

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

风声的专栏 626

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

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

Rust LeetCode443 算法题解

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

weixin_43379230的博客 178

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

jre9下载 jdk9

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

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

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

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

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

wfly blog 399

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

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

ZenovaEdgeOS的博客 560
上一篇: WebAssembly AI 插件:浏览器端推理引擎的设计与 Rust 实践
下一篇: Rust 错误处理模式:从 Result 到 thiserror 的生产级代码组织
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值