Rust 并发编程:从线程到 async/await 的并发模型与数据竞争防护

Rust语言核心优势与开发实战指南 Rust作为现代系统编程语言,通过所有权系统和零成本抽象等创新设计,在保证内存安全的同时实现C++级别的高性能。其编译时借用检查机制有效消除数据竞争和悬垂指针,使得开发者能够无畏并发地编写高效代码。这种特性使Rust在系统工具、Web后端、区块链等领域展现出独特优势,如Firefox引擎改用Rust后性能提升10倍。开发环境搭建涉及rustup工具链管理和镜像源优化,而异步编程模型基于轻量级Poll状态机,配合tokio等运行时可实现高性能网络服务。通过SQLx等库进行类型安全的数据库操作,结合Actix- 阅读详情

Rust 并发编程:从线程到 async/await 的并发模型与数据竞争防护

cover

一、Rust 并发的"编译器守护":为什么数据竞争在编译期就被消灭

Rust 的并发安全保证是语言级别的——编译器通过所有权系统和类型系统,在编译期就消除了数据竞争(Data Race)。这与 C++ 的运行时检测和 Go 的竞态检测器(Race Detector)有本质区别:Rust 的数据竞争是编译错误,而非运行时 Bug。

但 Rust 的并发安全并非没有代价——严格的借用规则使得某些并发模式无法直接表达。例如,多个线程同时读取一个可变数据结构,在 C++ 中只需加锁,在 Rust 中还需要证明锁的保护范围覆盖了所有访问路径。理解 Rust 并发模型的设计哲学,是正确使用并发原语的前提。

二、Rust 并发模型的层次:线程、通道与异步

flowchart TB
    A[Rust 并发模型] --> B[OS 线程: std::thread]
    A --> C[消息传递: std::sync::mpsc]
    A --> D[共享状态: Mutex/RwLock + Arc]
    A --> E[异步运行时: async/await + Tokio]

    B --> B1[适合: CPU 密集型任务]
    B --> B2[开销: 线程创建 + 上下文切换]

    C --> C1[适合: 生产者-消费者模式]
    C --> C2[优势: 无需共享可变状态]

    D --> D1[适合: 多线程共享数据]
    D --> D2[风险: 死锁 + 锁粒度]

    E --> E1[适合: I/O 密集型任务]
    E --> E2[优势: 轻量级 + 高并发]

三、Rust 并发的代码实践

3.1 线程与消息传递

/**
 * 生产者-消费者模式
 * 使用通道(Channel)实现线程间通信
 * Rust 的通道是类型安全的:发送端和接收端的类型由编译器保证一致
 */
use std::sync::mpsc;
use std::thread;

pub fn producer_consumer_demo() {
    // 创建通道
    let (tx, rx) = mpsc::channel();

    // 生产者线程
    let producer = thread::spawn(move || {
        let items = vec!["任务A", "任务B", "任务C"];
        for item in items {
            // send 返回 Result,处理接收端已关闭的情况
            if tx.send(item).is_err() {
                println!("接收端已关闭,停止发送");
                break;
            }
            thread::sleep(std::time::Duration::from_millis(100));
        }
    });

    // 消费者线程
    let consumer = thread::spawn(move || {
        // recv 会阻塞等待,返回 Result 处理发送端关闭
        while let Ok(item) = rx.recv() {
            println!("处理: {}", item);
        }
    });

    producer.join().unwrap();
    consumer.join().unwrap();
}

/**
 * 多生产者模式
 * 使用 tx.clone() 创建多个发送端
 */
pub fn multi_producer_demo() {
    let (tx, rx) = mpsc::channel();

    // 创建 3 个生产者
    let producers: Vec<_> = (0..3)
        .map(|id| {
            let tx_clone = tx.clone();
            thread::spawn(move || {
                for i in 0..5 {
                    let msg = format!("生产者{}-消息{}", id, i);
                    tx_clone.send(msg).unwrap();
                }
            })
        })
        .collect();

    // 必须丢弃原始 tx,否则 rx.recv() 永远不会返回 Err
    drop(tx);

    // 消费者
    while let Ok(msg) = rx.recv() {
        println!("收到: {}", msg);
    }

    for producer in producers {
        producer.join().unwrap();
    }
}

3.2 共享状态与 Mutex

/**
 * 共享状态并发
 * 使用 Arc<Mutex<T>> 实现多线程共享可变数据
 * Arc: 原子引用计数,跨线程共享所有权
 * Mutex: 互斥锁,保证同一时刻只有一个线程访问数据
 */
use std::sync::{Arc, Mutex};
use std::thread;

pub fn shared_counter_demo() {
    // Arc<Mutex<i32>>: 多线程共享的原子计数器
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter_clone = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            // lock() 返回 MutexGuard,自动实现 Deref 和 Drop
            // 作用域结束时自动释放锁
            let mut num = counter_clone.lock().unwrap();
            *num += 1;
            // MutexGuard 在此处 drop,释放锁
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("最终计数: {}", *counter.lock().unwrap());
    // 输出: 最终计数: 10
}

/**
 * 死锁避免:锁的获取顺序
 * 当需要同时持有多个锁时,必须按固定顺序获取
 */
pub fn deadlock_avoidance_demo() {
    let resource_a = Arc::new(Mutex::new("资源A"));
    let resource_b = Arc::new(Mutex::new("资源B"));

    let a1 = Arc::clone(&resource_a);
    let b1 = Arc::clone(&resource_b);

    // 线程1:先锁 A 再锁 B(固定顺序)
    let h1 = thread::spawn(move || {
        let _guard_a = a1.lock().unwrap();
        let _guard_b = b1.lock().unwrap();
        println!("线程1: 同时持有 A 和 B");
    });

    // 线程2:也先锁 A 再锁 B(相同顺序,不会死锁)
    let a2 = Arc::clone(&resource_a);
    let b2 = Arc::clone(&resource_b);
    let h2 = thread::spawn(move || {
        let _guard_a = a2.lock().unwrap();
        let _guard_b = b2.lock().unwrap();
        println!("线程2: 同时持有 A 和 B");
    });

    h1.join().unwrap();
    h2.join().unwrap();
}

3.3 RwLock:读写锁

/**
 * 读写锁:多读单写
 * 适合读多写少的场景
 * RwLock 允许多个线程同时读取,但写入时独占
 */
use std::sync::RwLock;

pub fn rwlock_demo() {
    let cache = Arc::new(RwLock::new(vec![1, 2, 3]));

    // 读线程:多个线程可以同时读取
    let mut read_handles = vec![];
    for i in 0..3 {
        let cache_clone = Arc::clone(&cache);
        read_handles.push(thread::spawn(move || {
            let data = cache_clone.read().unwrap();
            println!("读线程{}: {:?}", i, *data);
        }));
    }

    // 写线程:独占访问
    let cache_write = Arc::clone(&cache);
    let write_handle = thread::spawn(move || {
        let mut data = cache_write.write().unwrap();
        data.push(4);
        println!("写线程: 添加了元素");
    });

    for h in read_handles {
        h.join().unwrap();
    }
    write_handle.join().unwrap();
}

四、Rust 并发的常见陷阱与性能考量

Mutex 锁的持有时间:Rust 的 MutexGuard 在作用域结束时自动释放锁,但如果在持有锁期间执行耗时操作(如 I/O 或长时间计算),会阻塞其他线程。建议将临界区缩到最小——只在修改数据时持锁,计算和 I/O 在锁外执行。

Arc 的循环引用:Arc 使用引用计数管理生命周期,如果两个 Arc 互相引用(如父节点持有子节点的 Arc,子节点也持有父节点的 Arc),会形成循环引用,导致内存泄漏。解决方案是使用 Weak<T> 打破循环——子节点持有父节点的 Weak 引用而非 Arc。

通道的背压问题:如果生产者速度远快于消费者,通道中的消息会无限堆积,导致内存溢出。mpsc::channel() 创建的是无界通道,建议使用 mpsc::sync_channel(capacity) 创建有界通道——当通道满时,生产者的 send 会阻塞,实现背压控制。

async/await 与线程的混合:Rust 的异步运行时(如 Tokio)在 OS 线程上调度多个 Future。在 async 函数中调用阻塞操作(如 std::thread::sleep 或同步 I/O)会阻塞整个 OS 线程,影响其他 Future 的执行。建议使用 tokio::task::spawn_blocking 将阻塞操作移到专用线程池。

五、总结

Rust 并发模型的核心优势是编译期消除数据竞争,通过所有权系统和类型系统保证线程安全。并发原语的选择策略:CPU 密集型用 std::thread,I/O 密集型用 async/await,线程间通信优先用通道(Channel),共享可变状态用 Arc<Mutex<T>>。落地时注意:临界区缩到最小、通道使用有界变体防止内存溢出、async 函数中避免阻塞操作、多锁场景按固定顺序获取防止死锁。

补充落地建议:围绕“Rust 并发编程:从线程到 async/await 的并发模型与数据竞争防护”继续推进时,应把验收标准写成可执行清单。性能类方案要给出基准数据,架构类方案要给出故障隔离方式,AI 类方案要给出质量评估和人工兜底策略。每一次迭代都应回答三个问题:收益是否可量化,失败是否可回滚,维护成本是否被团队接受。

如果短期资源有限,可以先保留最关键的观测指标,包括处理耗时、失败率、资源占用和人工介入次数。等这些指标稳定后,再扩展自动化能力。这样的节奏更慢,但风险更低,也更符合生产级技术文章强调的工程可验证性。

从Termaxa案例看AI Agent并发安全:Rust架构设计与工程实践 在分布式系统和微服务架构中,并发控制与状态隔离是保障系统稳定性的核心基础。其原理在于通过锁机制、会话管理和资源隔离等技术,确保多用户或多进程访问时数据的一致性与安全性。这一技术价值在于构建高可靠、可扩展的服务架构,避免资源竞争和状态污染问题。在AI Agent开发领域,这些传统工程挑战正以新的形式重现,特别是在多用户并发场景下。本文基于Termaxa项目的双用户测试失败案例,深入探讨了AI Agent在**并发控制**和**状态管理**方面的工程实践。通过Rust语言构建的CLI Agent框架示例,展示了 阅读详情

相关推荐

并发的本质:不是同时干活,而是高效调度等待时间

并发(Concurrency)是一种应对I/O等待、用户交互和定时任务等不确定事件的系统设计范式,其核心原理在于通过协作式调度将阻塞操作显式化,实现单资源多任务的高效复用。它区别于并行(Parallelism),不依赖硬件扩展,而强调状态管理与执行时机控制。技术价值体现在提升吞吐量、降低延迟、增强响应性与资源利用率,广泛应用于高并发Web服务、实时消息系统、微服务网关及云原生后端开发。本文以咖啡店类比切入,深入解析goroutine、async/await、asyncio等主流模型的共性本质,并聚焦取消机制

xiang_fu的博客 383

从Termaxa案例看Rust构建安全AI Agent:多用户场景下的隔离与并发设计

在AI Agent与自动化工具开发领域,安全性与并发处理是核心挑战。AI Agent作为理解自然语言并执行操作的自动化程序,其安全机制需从单点防护扩展到系统性设计。传统安全门测试关注原子性权限检查,但在真实多用户并发场景下,状态污染、资源竞争等系统性风险凸显。Rust语言凭借内存安全、并发安全及高性能特性,成为构建可靠CLI工具的理想选择。通过所有权系统与借用检查器,Rust能在编译期预防数据竞争,结合tokio异步运行时实现高效并发。本文以Termaxa项目为例,探讨如何设计会话隔离架构、实现安全策略层,

weixin_34161029的博客 372

Rust实现高性能Web应用防火墙(WAF)核心技术与实践

Web应用防火墙(WAF)作为网络安全的关键防线,其核心原理是通过深度检测HTTP/HTTPS流量来防御SQL注入、XSS等攻击。现代WAF需要平衡安全性与性能,传统方案常面临内存安全与吞吐量的矛盾。Rust语言凭借所有权系统和零成本抽象,既能消除内存安全问题,又能实现接近C的性能水平。在工程实践中,结合异步IO框架tokio和SIMD指令优化,可使规则匹配速度提升5-7倍。本文以复刻雷池SafeLine为例,详解如何用Rust构建支持50Gbps吞吐、2000+安全规则的高性能WAF,涵盖流量分类、连接跟

weixin_34292402的博客 408

Rust与Python完全指南:从零开始理解两门语言的区别与关系

Rust与Python对比与协同指南 本文深入对比了Rust和Python两种编程语言的核心特性、适用场景及协同使用方法。Python以其简洁语法和丰富生态著称,适合快速开发、数据分析和Web应用;Rust则凭借内存安全和高效性能,成为系统编程和高并发场景的首选。两者在类型系统、内存管理和并发模型上差异显著:Python动态灵活但受GIL限制,Rust静态严谨但学习曲线陡峭。 通过PyO3工具链,开发者可将Rust高性能模块无缝集成到Python项目中,典型案例包括: 使用Rust加速数据处理管道 构建高性

油墨香^-^的博客 274

Python asyncio 入门:从伪异步到真正高并发的实战指南

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

weixin_34245082的博客 434

Python性能瓶颈实战:用Rust替换7%核心代码提升10倍性能

Python作为主流数据与AI开发语言,常因GIL限制、GC毛刺和C扩展内存不安全等问题,在高并发、实时计算和大文件处理场景中遭遇性能瓶颈。其本质是解释执行与运行时抽象带来的确定性开销。Rust凭借零成本抽象、所有权内存模型和稳定C ABI,成为Python原生加速最务实的补充方案——不替代胶水层,而精准强化CPU密集型‘肌肉模块’。本文聚焦真实生产环境中的字符串解析、数值聚合、高并发I/O编排与内存安全加固四大高频痛点,结合PyO3、simd-json、dashmap等关键技术选型,详解如何以最小改造代价

dieyuqi2955的博客 308

tmux-rs:用Rust重写tmux,打造内存安全的终端复用神器

tmux-rs是一个使用Rust语言重写的tmux终端复用器项目,它保留了tmux所有核心功能的同时,通过Rust的内存安全特性为开发者带来了前所未有的可靠性和性能保障。这个项目不仅是对经典工具的现代化重构,更是Rust系统编程能力的一次重要展示。 ## 项目背景与价值定位 tmux作为Unix/Linux系统中最受欢迎的终端复用工具,自2007年发布以来已经成为开发者和系统管理员的必备工具。

gitblog_00120的博客 735

Rust入门实战:环境配置、Web开发与跨语言调用全链路指南

Rust语言凭借内存安全、高性能和可靠的并发模型,在系统开发、服务端和嵌入式领域持续升温。对新手而言,最关键的起步并非死磕所有权和生命周期,而是先打通工具链、依赖源和编译调试这条底层链路。本文从通用概念切入,介绍如何通过rustup管理工具链、配置Cargo镜像源、在VSCode中高效运行Rust代码,并围绕actix-web实现RESTful API,通过C ABI实现跨语言调用,同时提及GPUI、嵌入式开发和二进制分析等进阶方向。无论你是准备写第一行Rust代码,还是为团队做技术选型,都能从中获得工程落

weixin_33858336的博客 320

用Rust为AI应用构建安全防线:从Transformer模型到工程实践

在AI应用开发中,内存安全和系统可靠性是保障服务稳定运行的基础。通过编译时内存安全检查、零成本抽象等机制,可以从原理上消除缓冲区溢出、数据竞争等常见漏洞。这些特性对于构建高并发、高性能的AI服务具有重要技术价值,尤其在模型部署和API服务场景中。结合当前AI工程化趋势,采用Rust语言重构关键组件,能为Transformer等大模型提供更安全可靠的运行时环境。本文通过OpenClaw案例,展示如何用Rust解决AI应用裸奔漏洞,并探讨WASM沙箱等实践方案。

weixin_33804582的博客 414

跨域思考:构建程序员的通用建模心智模型

在分布式系统与多技术栈日益普及的今天,开发者面临的核心挑战已从‘掌握工具’转向‘理解范式’。数据库、编程语言、中间件等技术表象之下,共存着状态管理、并发控制、数据一致性、查询优化和资源调度五大底层计算范式。真正制约成长的并非知识广度,而是能否将MySQL的事务、Rust的所有权、Redis的原子操作等具体实现,抽象为对‘状态变更可逆性’‘共享资源协调’‘异常下数据确定性’等本质问题的统一认知。这种跨语言、跨存储的通用建模能力,支撑高可用架构设计、异构系统集成与性能瓶颈归因,是资深工程师突破职业平台期、实现技

diedangxiang4092的博客 454

8.5/Q1,Charls最新高分文章解读!

8 257名受试者中,672人(8.14%)在9年内发生过卒中。在调整的多因素cox回归模型中,TyG和ABSI仍然是卒中的预测因素,TyG的HR为1.25(95%CI:1.06~1.47),ABSI的HR为1.33(95%CI:1.06~1.68)。TyG和ABSI联合诊断效能最高(AUC:0.579,95%CI:0.553~0.597),而TyG(AUC:0.566,95%CI:0.544~0.587)和ABSI(AUC:0.533,95%CI:0.524~0.597)的诊断效能最低。

gsky_sci的博客 1017

从OpenClaw漏洞到Rust安全重构:WASM沙箱与内存安全实践

在软件工程领域,内存安全漏洞和反序列化漏洞(如fastjson、Log4j相关漏洞)是常见的安全威胁,它们常导致远程代码执行等严重风险。其原理在于程序对内存操作或外部数据解析缺乏安全边界控制,使得攻击者可利用缓冲区溢出、类型混淆等技术实施攻击。这类问题的技术价值在于推动开发者采用更安全的编程范式和语言,从根源上消除整类漏洞。应用场景广泛涉及Web服务、API网关、插件系统等需要处理不可信输入的环境。本文以OpenClaw框架的“裸奔漏洞”为切入点,探讨如何通过Rust语言的内存安全特性与WASM沙箱技术,系

weixin_30905981的博客 409

使用RustDesk或者AnyDesk的TCP隧道实现Codesys系列PLC的远程调试和下载

Codesys远程调试

exat500g的博客 7282

Rust机器学习实战:回归与分类的生产级实现

机器学习模型部署正从Python向系统级语言迁移,核心诉求是低延迟、高稳定性与资源可控性。Rust凭借零成本抽象、内存安全和无GC特性,成为边缘计算、嵌入式AI与MLOps服务的理想载体。其关键能力体现在数值计算可靠性(如QR分解替代正规方程)、编译期数据契约(如ndarray类型约束特征/标签维度)、以及no_std环境下的轻量模型嵌入(如rust-ml的查表sigmoid)。在回归任务中,岭回归与Theil-Sen等鲁棒算法可有效应对工业数据中的共线性与离群点;在分类场景下,逻辑回归的L2正则与KNN的

weixin_30808693的博客 508

从门禁到支付:Uniapp+NFC开发避坑指南(支持Mifare Classic)

本文详细介绍了Uniapp结合NFC技术开发门禁与支付系统的实战指南,特别针对Mifare Classic卡片进行深度优化。内容涵盖环境配置、设备兼容性处理、卡片安全机制解析以及高性能读写优化策略,帮助开发者快速实现跨平台的智能硬件交互解决方案。

t1u2v的博客 751

FreeRTOS --(15)信号量之概述

FreeRTOS 中使用信号量来做同步,信号量可以在任务中使用作为任务与任务间的同步,也可以在中断中使用(带 FromISR 的版本)中断与任务间的同步; 针对不同的应用场景,信号量分为两种: 1、二值信号量; 2、计数信号量; 1、二值信号量 1.1、Usage 顾名思义,二值信号量只有两个值:0 和 1;它用于简单场景下的任务与任务、中断与任务之间的同步,比如:一个任务,在等待某个资源到位后,才能够继续执行,在得到这个资源之前,它处于阻塞状态,假如一个中断来了,给出了这个资源,那么.

StephenZhou 6520

从入门到精通:Deadpool异步连接池的高级配置与最佳实践

Deadpool是一个极其简单的Rust异步连接池实现,专为Rust的async-await语法设计,提供高效、可靠的连接管理方案。无论是数据库连接、缓存连接还是其他资源池化需求,Deadpool都能通过简洁的API和灵活的配置满足各种场景。 ## 什么是Deadpool异步连接池? Deadpool提供两种核心池化实现:**Managed Pool**(托管池)和**Unmanaged Po

gitblog_00230的博客 828

OSMDroid(1)——OSM简介,基础例子搭建

1.OSMDroid简介 Osmdroid是一款完全开源的地图基本操作SDK,相比于现在普遍使用的百度地图,高德地图,谷歌地图等最大的好处就是开源。 最近在做一个军方项目,要求完全不能联网,从开发到应用整个阶段都是在局域网进行,相比之下采用了OSMDroid这个SDK作为解决方案。 先来看OSMDroid,便是(OpenStreetMapForAndroid),后面都简称OSM...

robotskly的博客 6182

Rust项目AI代码泛滥?从工具链到审查守好质量关

Rust以严格的编译器检查和内存安全著称,其所有权与生命周期机制在编译期就拦截了大量潜在错误。然而,当AI辅助编程工具批量生成代码时,这些“看起来正确”的代码往往在cargo check阶段就暴露出借用冲突、错误处理潦草、并发模型混乱等问题,给项目维护者带来沉重的PR审查压力。要化解这一矛盾,关键在于建立从提示词约束、自动化质量门禁到人工审查checklist的全流程防线:通过cargo fmt统一格式,用cargo clippy拦截代码坏味道,再结合CI流水线将低质量PR拒之门外。同时,合理设计提示词让A

weixin_34068198的博客 362

税务某局 webpack 登录接口逆向分析

我们再回到接口逻辑去看一下,发现每次请求前,还有两个接口,getpublickey和sendsm4,这里分析了一下调用逻辑,sm4这个接口用到一个参数是由publickey返回的一个参数而来,这个参数又经过内部加密处理,我们找到这个参数加密的地方,大概是在这个位置。我们还是顺着逻辑将加载器扣下来,然后用一个变量去接收,有了加载器,我们直接把加密代码扣下来做下处理,把一些用到的参数整理下如下。打上断点分析后,_utils_getuuid这个很长的变量也是加载器的一个函数,我们将这段代码也扣下来,如下。

码王吴彦祖的博客 403

ThingsBoard集群部署之k8s

今天终于有时间去搞这个啦,拖了很久了,一直没时间,因为我本地没有那么多机器资源,开虚拟机不够,如果租用阿里云服务器,需要有充值的时间,因为这个费用是按小时付费,需要有连贯的时间来搞才行,今天恰好有时间,就开始搞了,弄成功搞出来了,特地写博客记录下来。

AldrichEugene 1176

Linux运维实战:十款开源安全工具与高并发原理深度解析

在系统运维与安全领域,构建稳固的防御体系和保障服务高性能运行是两大核心目标。从原理层面看,系统安全依赖于分层的纵深防御体系,涵盖系统加固、入侵检测、漏洞扫描与日志审计等多个层面;而服务的高并发处理能力则根植于对进程、线程、I/O多路复用等底层机制的深刻理解。在工程实践中,通过组合使用成熟的开源工具,可以高效落地这些安全与性能理念。例如,利用 **Lynis** 进行系统安全审计,结合 **Suricata** 实现网络入侵检测,能够有效构建主动防御能力。同时,理解 **epoll** 等I/O模型的工作原理

weixin_33912246的博客 374

PCL 读取和保存点云

PCL (Point Cloud Library) 是一个用于处理 3D 点云数据的开源库。在处理点云数据时,常见的任务包括点云的读写和可视化。PCL 提供了强大的 IO 模块来读取和写入各种格式的点云文件,并且提供了可视化模块来对点云进行渲染和显示。点云的读写与显示是很多 3D 数据处理任务的基础步骤,通过这些步骤,可以对点云进行预处理、分析和操作。

纵马踏花向自由 1741

Rust的async函数中的局部变量跨await点存活与状态机生成的内存布局

Rust的async函数中的局部变量跨await点存活与状态机生成的内存布局是一个既有趣又充满挑战的话题。在异步编程中,理解变量如何跨越await点存活以及状态机如何管理这些变量的内存布局,对于编写高效、安全的异步代码至关重要。只有跨越await点的变量才会被存储在状态机中,而其他临时变量则可能在状态切换时被释放。通过检查生成的状态机结构,开发者可以更清晰地看到变量的存储方式,从而优化内存使用或排查问题。如果一个变量在await点之后不再使用,它可能不会被包含在状态机的内存布局中。**状态机的内存布局**

mqsnwo_817的博客 61

贝叶斯统计 [韦来生编]

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

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...

blog_os高可用性:容错与故障恢复机制

在现代操作系统开发中,高可用性(High Availability)是衡量系统可靠性的关键指标。对于用Rust编写的操作系统blog_os而言,构建健壮的容错(Fault Tolerance)和故障恢复(Fault Recovery)机制至关重要。本文将深入探讨blog_os如何通过异常处理、双重故障防护、异步任务管理等技术实现系统的高可用性。 ## 操作系统高可用性的核心挑战 操作系统的可用...

gitblog_00969的博客 735

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

Semantic Router × Gateway API Inference Extension(GAIE):以 x-selected-model 串联语义池选择与端点调度

本文是语义路由项目(semantic-router)将**语义模型池选择**与 Kubernetes Gateway API 的 **InferencePool 端点选择**组合使用的实战指南。Semantic Router 依据请求含义、策略与配方状态选出逻辑模型或池,并写入 `x-selected-model` 请求头;GAIE 通过 `HTTPRoute` 头匹配把该池映射为 `Infere

gitblog_00716的博客 440

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

上一篇: WASM + AI 生态全景:边缘智能部署的技术栈、运行时与跨语言互操作实践
下一篇: WASM 边缘推理:Rust + ONNX Runtime 的浏览器端模型部署实践
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值