系统级并发控制:用 Go/Rust 双语实现无锁队列(Lock-free Queue)的对比剖析

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

系统级并发控制:用 Go/Rust 双语实现无锁队列(Lock-free Queue)的对比剖析

cover

在高并发和低延迟系统开发中,传统的基于互斥锁(Mutex)的并发队列往往会成为系统的性能瓶颈。锁竞争带来的线程上下文切换、内核态与用户态的频繁转换,以及难以避免的优先级反转问题,极大地限制了多核 CPU 的算力输出。为了追求极致吞吐与微秒级的延迟,无锁(Lock-free)数据结构应运而生。

本文将深入探究无锁队列的底层设计,剖析内存屏障与 CPU 缓存行对无锁结构的影响,并通过 Go 和 Rust 双语实现一个基于环形缓冲区(Ring Buffer)的高性能无锁队列(MPMC,多生产者多消费者),最后对比两者在内存模型与垃圾回收机制上的底层差异。

一、多线程同步的终极战场:传统锁的性能瓶颈

在多线程编程中,保护共享资源的经典方式是互斥锁(Mutex)。然而,在每秒需要处理数百万级甚至数千万级请求的超高并发系统(如高频交易系统、网络网关、游戏服务器)中,互斥锁的代价变得难以为继:

  1. 上下文切换开销:当一个线程尝试获取互斥锁失败时,操作系统通常会将其挂起,放入等待队列。这涉及 CPU 寄存器状态的保存与恢复、内核调度器介入以及 CPU 缓存(L1/L2/L3)的失效。这一过程往往需要消耗数微秒的时间。
  2. 锁竞争与线程饥饿:多核 CPU 下,当数十个线程同时争抢同一个锁时,会导致严重的 CPU 争用(Contention)。大多数线程被挂起或处于自旋状态,使得多核 CPU 的并行计算优势丧失殆尽,吞吐曲线呈现非线性甚至倒 V 型的恶化趋势。
  3. 优先级反转:低优先级线程持有锁,而高优先级线程因等待锁被挂起,中等优先级的线程又抢占了低优先级线程的 CPU 时间片,导致高优先级任务无限期延迟。

相比之下,无锁(Lock-free)设计通过硬件提供的原子指令(如 CAS,Compare-And-Swap)来避免线程的阻塞挂起。在无锁设计中,即使某个线程在执行过程中被挂起,也不会阻碍其他线程的向前推进,从而保证了系统整体的活性(Liveness)。

二、无锁队列底层运行原理与内存秩序(Memory Ordering)解构

要设计一个高性能的无锁队列,必须解决两个核心挑战:数据竞争与内存可见性。这两者在底层紧密依赖于 CPU 的指令重排与内存屏障(Memory Barrier)。

2.1 内存秩序(Memory Ordering)与指令重排

现代 CPU 为了提高执行效率,会进行指令乱序执行(Out-of-Order Execution),且编译器在编译时也会进行代码优化重排。对于单线程而言,这种重排保证了执行结果的语义一致性;但在多线程并发访问共享内存时,重排会导致严重的“内存可见性”问题。

为了解决这个问题,硬件和编程语言定义了内存模型,并通过内存屏障来约束重排行为。在 Rust 和 Go 中,原子操作都需要指定内存秩序或遵循特定的可见性规则:

  • Relaxed(宽松):没有任何内存屏障的约束,仅保证操作本身是原子的,不保证其他内存读写的顺序。
  • Acquire(获取):用于读操作。确保该操作之后的读写指令绝不能被重排到该操作之前。
  • Release(释放):用于写操作。确保该操作之前的读写指令绝不能被重排到该操作之后。
  • Acquire-Release(获取-释放组合):常用于 Read-Modify-Write(如 CAS)。结合了前两者的效果。
  • SeqCst(顺序一致性):最强的内存秩序,保证所有线程看到的所有 SeqCst 操作都有一个全局统一的执行顺序,且插入了全套内存屏障,开销最大。

2.2 环形无锁队列(Bounded MPMC Queue)设计原理

这里我们采用经典的基于固定容量环形缓冲区(Ring Buffer)的多生产者多消费者(MPMC)无锁队列。每个槽位(Slot)包含数据和对应的序列号(Sequence)。

  • 写入(Enqueue)逻辑:

    1. 生产者读取 tail 指针,计算槽位索引 idx = tail % capacity。
    2. 检查该槽位的序列号。若 sequence == tail,说明该槽位为空,可以写入。
    3. 尝试使用 CAS 将 tail 递增。
    4. 成功抢占 tail 值的线程,将数据放入槽位,并将槽位的序列号修改为 tail + 1,用以通知消费者可以读取。
    5. 若 CAS 失败,说明其他生产者抢先一步,当前线程自旋重试。
  • 读取(Dequeue)逻辑:

    1. 消费者读取 head 指针,计算槽位索引 idx = head % capacity。
    2. 检查该槽位的序列号。若 sequence == head + 1,说明该槽位已有新数据,可以读取。
    3. 尝试使用 CAS 将 head 递增。
    4. 成功抢占 head 值的线程,取出槽位中的数据,并将槽位的序列号修改为 head + capacity,用以通知生产者可以重新写入。
    5. 若 CAS 失败,说明其他消费者抢先一步,当前线程自旋重试。
graph TD
    A[线程 A & B 并发调用 Enqueue] --> B[读取当前 Tail 索引]
    B --> C[定位 Ring Buffer 槽位: idx = Tail % Capacity]
    C --> D{读取槽位 Sequence == Tail?}
    D -- 否 (队列已满或被抢占) --> B
    D -- 是 --> E[尝试 CAS 递增 Tail: Tail -> Tail + 1]
    E -- 失败 (被其他线程抢占) --> B
    E -- 成功 (成功抢占槽位) --> F[将数据写入槽位]
    F --> G[更新槽位 Sequence 为 Tail + 1]
    G --> H[Enqueue 成功]

三、Go 与 Rust 的生产级无锁队列双语实现

3.1 Go 语言版本的无锁队列实现

在 Go 中,我们利用 unsafe.Pointer 以及内置的 sync/atomic 包来实现高并发的原子操作。为了防止伪共享,我们通过填充结构体来保证关键变量在不同的 Cache Line(缓存行)中。

package lfq

import (
	"runtime"
	"sync/atomic"
	"unsafe"
)

// cacheLinePad 用于防止伪共享(False Sharing),填充 64 字节(现代 CPU 典型缓存行大小)
type cacheLinePad [8]uint64

type node struct {
	sequence uint64
	value    interface{}
}

type GoLockFreeQueue struct {
	_        cacheLinePad
	capacity uint64
	mask     uint64
	ring     []node
	_        cacheLinePad
	head     uint64
	_        cacheLinePad
	tail     uint64
	_        cacheLinePad
}

// NewGoLockFreeQueue 创建一个固定容量的无锁队列,容量必须是 2 的幂以优化取模运算
func NewGoLockFreeQueue(capacity uint64) *GoLockFreeQueue {
	if capacity&(capacity-1) != 0 {
		panic("Capacity must be a power of 2")
	}

	ring := make([]node, capacity)
	for i := uint64(0); i < capacity; i++ {
		ring[i].sequence = i
	}

	return &GoLockFreeQueue{
		capacity: capacity,
		mask:     capacity - 1,
		ring:     ring,
		head:     0,
		tail:     0,
	}
}

// Enqueue 向队列中写入元素,如果队列满则自旋等待
func (q *GoLockFreeQueue) Enqueue(val interface{}) {
	var pos uint64
	for {
		pos = atomic.LoadUint64(&q.tail)
		n := &q.ring[pos&q.mask]
		seq := atomic.LoadUint64(&n.sequence)
		diff := int64(seq) - int64(pos)

		if diff == 0 {
			if atomic.CompareAndSwapUint64(&q.tail, pos, pos+1) {
				n.value = val
				atomic.StoreUint64(&n.sequence, pos+1)
				return
			}
		} else if diff < 0 {
			// 队列已满,让出 CPU 时间片,避免死循环消耗 CPU
			runtime.Gosched()
		} else {
			pos = atomic.LoadUint64(&q.tail)
		}
	}
}

// Dequeue 从队列中读取元素,如果队列空则自旋等待
func (q *GoLockFreeQueue) Dequeue() interface{} {
	var pos uint64
	for {
		pos = atomic.LoadUint64(&q.head)
		n := &q.ring[pos&q.mask]
		seq := atomic.LoadUint64(&n.sequence)
		diff := int64(seq) - int64(pos + 1)

		if diff == 0 {
			if atomic.CompareAndSwapUint64(&q.head, pos, pos+1) {
				val := n.value
				n.value = nil // 释放引用,避免垃圾回收内存泄漏
				atomic.StoreUint64(&n.sequence, pos+q.capacity)
				return val
			}
		} else if diff < 0 {
			// 队列为空,让出 CPU 时间片
			runtime.Gosched()
		} else {
			pos = atomic.LoadUint64(&q.head)
		}
	}
}

3.2 Rust 语言版本的无锁队列实现

在 Rust 中,我们通过标准库的 std::sync::atomic 包实现无锁队列。Rust 允许我们精细化指定内存屏障(如 Acquire 和 Release),以获取最优的编译输出和硬件性能。此外,利用 Rust 的所有权体系,我们必须安全地包裹未初始化或已被消费的内存空间。

use std::cell::UnsafeCell;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::thread;

// 槽位结构,为了防止伪共享,将节点对齐到 64 字节的缓存行
#[repr(align(64))]
struct Node<T> {
    sequence: AtomicUsize,
    value: UnsafeCell<Option<T>>,
}

pub struct RustLockFreeQueue<T> {
    buffer: Vec<Node<T>>,
    capacity: usize,
    mask: usize,
    // 将 head 和 tail 独立对齐,确保不会映射到同一个 Cache Line
    #[header_pad]
    head: align_to_64::Align64<AtomicUsize>,
    tail: align_to_64::Align64<AtomicUsize>,
}

mod align_to_64 {
    use std::sync::atomic::AtomicUsize;
    #[repr(align(64))]
    pub struct Align64<T>(pub T);
}

// 安全声明:队列可以在多个线程之间安全传递和并发共享
unsafe impl<T: Send> Send for RustLockFreeQueue<T> {}
unsafe impl<T: Send> Sync for RustLockFreeQueue<T> {}

impl<T> RustLockFreeQueue<T> {
    pub fn new(capacity: usize) -> Self {
        assert!(capacity.is_power_of_two(), "Capacity must be a power of 2");
        let mut buffer = Vec::with_capacity(capacity);
        for i in 0..capacity {
            buffer.push(Node {
                sequence: AtomicUsize::new(i),
                value: UnsafeCell::new(None),
            });
        }

        RustLockFreeQueue {
            buffer,
            capacity,
            mask: capacity - 1,
            head: align_to_64::Align64(AtomicUsize::new(0)),
            tail: align_to_64::Align64(AtomicUsize::new(0)),
        }
    }

    pub fn enqueue(&self, data: T) {
        let mut pos = self.tail.0.load(Ordering::Relaxed);
        loop {
            let node = &self.buffer[pos & self.mask];
            // 对 sequence 的读取要求 Acquire,确保前面的写入对其可见
            let seq = node.sequence.load(Ordering::Acquire);
            let diff = seq as isize - pos as isize;

            if diff == 0 {
                // 抢占 tail 指针。如果成功,锁定此槽位
                match self.tail.0.compare_exchange_weak(
                    pos,
                    pos + 1,
                    Ordering::Relaxed,
                    Ordering::Relaxed,
                ) {
                    Ok(_) => {
                        // 写入数据:UnsafeCell 提供了内部可变性,在 CAS 之后我们独占该槽位
                        unsafe {
                            *node.value.get() = Some(data);
                        }
                        // 释放槽位:通过 Release 保证前面的数据写入在此之前完成
                        node.sequence.store(pos + 1, Ordering::Release);
                        return;
                    }
                    Err(actual) => {
                        pos = actual;
                    }
                }
            } else if diff < 0 {
                // 队列已满,让出 CPU 执行权
                thread::yield_now();
                pos = self.tail.0.load(Ordering::Relaxed);
            } else {
                pos = self.tail.0.load(Ordering::Relaxed);
            }
        }
    }

    pub fn dequeue(&self) -> T {
        let mut pos = self.head.0.load(Ordering::Relaxed);
        loop {
            let node = &self.buffer[pos & self.mask];
            let seq = node.sequence.load(Ordering::Acquire);
            let diff = seq as isize - (pos + 1) as isize;

            if diff == 0 {
                // 抢占 head 指针
                match self.head.0.compare_exchange_weak(
                    pos,
                    pos + 1,
                    Ordering::Relaxed,
                    Ordering::Relaxed,
                ) {
                    Ok(_) => {
                        // 读取并移出数据
                        let data = unsafe {
                            let val_ptr = node.value.get();
                            (*val_ptr).take().expect("Node value must be present")
                        };
                        // 更新 sequence,允许新的 enqueue 操作
                        node.sequence.store(pos + self.capacity, Ordering::Release);
                        return data;
                    }
                    Err(actual) => {
                        pos = actual;
                    }
                }
            } else if diff < 0 {
                // 队列为空,让出 CPU 执行权
                thread::yield_now();
                pos = self.head.0.load(Ordering::Relaxed);
            } else {
                pos = self.head.0.load(Ordering::Relaxed);
            }
        }
    }
}

四、无锁设计的性能代价与边界博弈

虽然无锁队列在微观性能测试(Micro-benchmark)中拥有惊人的性能表现,但在实际的生产架构中,无锁设计并非万灵药。深入理解其带来的开销和潜在缺陷是合理选型的关键。

4.1 缓存一致性总线风暴(Bus Storm)

无锁算法通常通过循环和 CAS 原子指令来进行重试。在极端的高并发场景下,几十个 CPU 核心会频繁向同一个内存地址发起 Compare-And-Swap 总线锁指令。
在多核架构中,这意味着 CPU 核心之间会不断发送缓存一致性协议(如 MESI)的控制消息。当某个核心 CAS 成功修改了共享变量(如 tail),所有其他核心中对应的 L1/L2 缓存行都将被标记为无效(Invalidate)。这会导致大量的核心在下一次循环中必须从 L3 缓存甚至主内存中重新加载数据,造成所谓的“缓存行跳跃(Cache Line Bouncing)”和总线带宽拥堵,反而导致系统整体性能比使用互斥锁还要低。

4.2 伪共享(False Sharing)与缓存行对齐

在上述的 Go 和 Rust 实现中,均有对 head、tail 变量及槽位进行对齐填充的处理。这是为了解决伪共享问题。
现代 CPU 读取内存是按缓存行(通常为 64 字节)读取的。如果 head 与 tail 存储在相邻的内存地址,它们极有可能落在同一个缓存行中。当核心 1 修改了 tail,就会强行使核心 2 的 head 缓存行失效,导致核心 2 在读取 head 时必须重新加载物理内存。通过在变量两端填充足够的空字节(或声明 alignment),迫使它们映射到不同的缓存行,能够成倍提升无锁队列的并发性能。

4.3 内存释放与 ABA 问题

在基于链表的无锁队列设计中,最棘手的难题之一是内存回收问题。
假设线程 1 读取了节点 A 处的指针,在尝试 CAS 替换 A 时被挂起。线程 2 移除了 A,并释放了其内存,接着又创建了一个新节点,而由于内存分配器重用机制,新节点正好分配在地址 A 处。当线程 1 恢复执行,对其进行 CAS 检查时,发现地址依然是 A,判定没有发生变化并完成了替换。但实际上链表结构已经被严重破坏。这就是著名的 ABA 问题。

在 Go 中,由于有内置的垃圾回收器(Garbage Collector),Go 运行时会自动管理并追踪所有被引用的指针,在确保没有任何核心持有该内存后才进行回收,天然地规避了 ABA 问题。
而在无 GC 机制的 Rust 中,直接操作 AtomicPtr 必须引入复杂的 Epoch-based 内存回收策略(如垃圾回收延迟追踪)或使用 Hazard Pointer。本文所实现的 Ring Buffer 无锁队列通过将内存预先分配在一块连续的切片中,并利用循环递增的 Sequence 序列号,从根本上避开了动态内存释放带来的 ABA 隐患。

五、总结

无锁队列以硬件原子操作替代传统的操作系统锁,最大程度降低了高并发环境下的上下文切换开销。但在实际落地中,开发者需要根据竞争烈度以及具体业务指标进行权衡:

  1. 中低竞争场景:传统的互斥锁由于操作系统的自适应自旋(Adaptive Spin Lock)优化,表现已经非常出色,盲目改用无锁可能会使 CPU 在无数据时空转,徒增功耗。
  2. 多生产者多消费者(MPMC)超高竞争场景:若数据吞吐极大,应慎重评估无锁队列的总线风暴。此时,使用分段锁或并发批处理可能更优。
  3. 单生产者单消费者(SPSC)场景:由于不涉及多生产者抢占,无锁队列(如 Linux 内核的 kfifo)在此类场景下能够爆发出无与伦比的性能,是首选方案。
S4 HANA 1809+折旧过账(AFAB/AFABN)凭证行数据存储逻辑变迁:从BSEG到ACDOCA的深度解析 本文深度解析了S4 HANA 1809+版本中折旧过账(AFAB/AFABN)凭证行数据存储逻辑的变迁,从传统的BSEG表迁移到ACDOCA表。文章详细探讨了这一变更的技术背景、官方设计意图及实际影响,包括数据存储量减小和系统性能提升等优势。同时提供了升级项目的应对策略和最佳实践建议,帮助用户顺利过渡到新的数据存储模型。 阅读详情

相关推荐

Windows下PaddleOCR GPU版环境搭建全攻略(含CUDA 11.7避坑指南)

本文提供了一份详尽的Windows平台PaddleOCR GPU版环境搭建指南,重点涵盖CUDA 11.7与cuDNN的版本匹配、环境变量配置及常见避坑方法。通过使用Conda创建虚拟环境并安装匹配的PaddlePaddle-gpu版本,最终实现GPU加速的OCR推理,帮助开发者构建稳定高效的开发环境。

docker7nomad的博客 752

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

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

qq_36765170的博客 572

独立游戏开发者的新武器:实测腾讯混元3D自动绑骨,搭配Mixamo让角色动画制作效率翻倍

本文实测腾讯混元3D自动绑骨功能与Mixamo动画库的协同使用,显著提升独立游戏开发者的角色动画制作效率。通过解决卡通角色绑骨偏差、优化骨骼权重及动画状态机配置,使原本两周的流程缩短至三天,并分享Unity中的性能优化与版权合规要点。

weixin_42662605的博客 503

rust: Fan-out/Fan-in Pattern

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

Geovin Du Dream Park 166

如何在R中高效安装ropls及其依赖包

本文详细介绍了在R语言中高效安装ropls包及其依赖的完整流程。作为Bioconductor生物信息学分析包,ropls的安装需通过BiocManager管理器进行。文章提供了标准安装步骤、跨系统避坑指南及安装后验证方法,帮助用户解决R版本、编译环境和网络镜像等常见问题,确保代谢组学数据分析工具顺利部署。

efc123456的博客 910

(实战)[re:Invent 2018]-001:赛道分析-(致敬1024)

打印log

Rainbow 2786

Rust组织管理(AI回答)

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

yaoct的博客 154

UNet + Shuffle Attention:一种轻量高效的医学图像分割注意力机制

本文提出了一种轻量高效的医学图像分割方法,将Shuffle Attention模块嵌入UNet的上采样路径中。Shuffle Attention通过通道分组注意力机制增强关键特征,同时保持计算轻量化。该方法在上采样后应用注意力模块,有效融合高层语义与低层细节,计算开销小且易于部署。实验表明,该模型在保持UNet原有优势的基础上,通过注意力机制提升了特征聚焦能力,适用于多种图像分割任务。未来可进一步结合空间注意力或Transformer模块以增强模型性能。

Henry的博客 240

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

如果有云服务的话,可以基于 RustDesk 的 hbbs / hbbr 自己部署一套,不过会碰到一个问题:每台电脑装完客户端,都得手动去设置里填三样东西——ID 服务器、中继服务器、Key。填错一个就连不上,还得远程指导同事操作。这篇记录两种解决办法,以及云端编译的完整流程。内容基于 RustDesk 1.5.3 的源码。

风声的专栏 641

华为od 面试八股文_C++_04_含答案

华为od 面试八股文_C++_04_含答案

MISAYAONE的博客 2477

使用 Simulink + Simscape Electrical 对基于VSG控制的背靠背变流器整流侧进行建模与仿真

本文介绍了基于Simulink的直驱风电系统背靠背变流器整流侧虚拟同步发电机(VSG)建模方法。首先阐述了直驱风电系统结构和VSG控制的作用,然后详细指导了模型搭建过程:从创建项目、添加PMSG和变流器模块,到搭建主电路拓扑和实现VSG控制逻辑。重点说明了VSG控制器如何模拟传统同步发电机的特性,并提供了仿真设置和结果分析方法。该模型可用于研究风电系统在不同工况下的响应特性,为新能源发电系统设计提供重要参考。

amy_mhd的博客 182

Rust LeetCode443 算法题解

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

weixin_43379230的博客 197

【Godot】【工程】中文字体与多语言(缺字/体积/打包:一次性配置到位)

本文介绍了Godot游戏开发中的中文字体配置与多语言支持方案。主要内容包括:1)中文字体的全局与局部设置;2)使用子集化技术减小字体体积;3)多语言资源管理及翻译系统实现;4)语言切换机制与控件刷新方法;5)字体回退策略优化显示效果;6)打包优化建议。文章提供了从字体导入到多语言实现的完整解决方案,帮助开发者系统性解决中文显示和多语言支持问题,同时优化资源体积和性能表现。配套案例可供学习参考。

技术小甜甜:传播可落地技术,帮助个人和企业降低解决真实场景问题的成本 599

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

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

蓝牙模块HM-10手册

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

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

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

wfly blog 471

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

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

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

olegja3d的博客 216

深度学习工具包 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")

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

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

ZenovaEdgeOS的博客 562

Rust如何实现微服务网关的高并发与限流熔断机制

在现代互联网系统中,微服务架构已成为主流,而微服务网关则是整个系统的重要组成部分。当面对高并发、高可用性需求时,很多开发者对如何用 Rust 实现一个稳定可靠的网关存在疑惑,尤其是处理请求的幂等性、限流和熔断机制。本文将以 Rust 的实际案例为基础,结合生产环境中的具体经验,讲解如何设计和实现一个具备限流与熔断能力的微服务网关。

wuchangjian的专栏 116

第 1 讲:内存布局与所有权解剖——栈帧、胖指针与“移动/拷贝”在汇编层面的真实面目

看图最下面的(或者数组切片&[T]它在栈上占16 个字节,由(ptr, len)两个机器字组成。这就是系统编程里常说的胖指针(普通指针只有 8 字节地址,它胖了一倍,多带了一个 8 字节的长度或虚表指针)。痛点追问:C 语言里表示字符串切片只要一个 8 字节的char*,为什么 Rust 非要浪费双倍的栈空间搞成 16 字节?如果少掉len这一环会出什么乱子?回想一下 C 语言是怎么知道一个字符串在哪结束的:靠在内存末尾塞一个字节的\0求长度是 $O(N)$ 的苦力活:在 C 里调strlen(p)

yaoct的博客 170

【Rust算法硬核拆解】LeetCode 334 递增的三元子序列(贪心+O(1))

【LeetCode 334 递增的三元子序列】用一次扫描贪心实现:时间 O(n)、空间 O(1)。附 13 个单测与正确性说明。

weixin_43379230的博客 357

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

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

2601_96785163的博客 309

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

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

aifannihao的博客 222

rust: Push & Pull Pattern

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

Geovin Du Dream Park 120

我用 RustyPaste 做 AI Agent 云端存储

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

藏云阁技术社区 244

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

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

weixin_63115449的博客 186

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

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

Tony.Dong的专栏 481
上一篇: WasmEdge边缘计算环境中的轻量级GPU推理模型部署与CUDA核函数优化探索
下一篇: 工程迁移范式思考:从传统 OOP 业务开发到 Rust 内存确定性所有权范式的思想重塑与迁移指南
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值