Rust并发编程:线程、通道与锁深度解析

Rust实战:如何利用 mpsc 通道构建无阻塞的多线程应用 本文面向中级开发者,深入探讨了在 Rust 项目中如何利用 `std::sync::mpsc` 通道实现多线程通信以避免 UI 阻塞。文章结合实际代码,详细解析了命令执行结果回传、文件监控事件流处理两个核心场景。重点阐述了 `try_recv` 的非阻塞机制与 GUI 事件循环的配合原理,以及 `mpsc` 基于内存队列的所有权转移模型。通过“消息传递”架构,开发者可以构建出高效、解耦且响应迅速的应用程序。 阅读详情

Rust并发编程:线程、通道与锁深度解析

引言

在Rust开发中,并发编程是构建高性能应用的关键。作为一名从Python转向Rust的后端开发者,我深刻体会到Rust在并发安全方面的优势。Rust通过所有权系统和类型安全,在编译时保证并发安全,无需运行时同步开销。

并发编程核心概念

并发vs并行

概念含义
并发多个任务交替执行,同一时刻只有一个任务在执行
并行多个任务同时执行,需要多核CPU支持

Rust并发原语

  • 线程:std::thread
  • 通道:std::sync::mpsc 或 crossbeam-channel
  • 锁:std::sync::Mutex, std::sync::RwLock
  • 原子操作:std::sync::atomic
  • 条件变量:std::sync::Condvar

环境搭建与基础配置

基本线程创建

use std::thread;
use std::time::Duration;

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("Spawned thread: {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("Main thread: {}", i);
        thread::sleep(Duration::from_millis(1));
    }

    handle.join().unwrap();
}

线程返回值

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        "Hello from thread"
    });

    let result = handle.join().unwrap();
    println!("{}", result);
}

通道通信实战

单生产者单消费者

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let val = String::from("hi");
        tx.send(val).unwrap();
    });

    let received = rx.recv().unwrap();
    println!("Received: {}", received);
}

多生产者

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();
    let tx1 = tx.clone();

    thread::spawn(move || {
        tx.send(String::from("from thread 1")).unwrap();
    });

    thread::spawn(move || {
        tx1.send(String::from("from thread 2")).unwrap();
    });

    for received in rx {
        println!("Received: {}", received);
    }
}

使用crossbeam-channel

use crossbeam_channel as channel;
use std::thread;

fn main() {
    let (s, r) = channel::unbounded();

    thread::spawn(move || {
        s.send(42).unwrap();
    });

    println!("Received: {}", r.recv().unwrap());
}

锁机制实战

Mutex锁

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

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

    println!("Result: {}", *counter.lock().unwrap());
}

RwLock读写锁

use std::sync::{Arc, RwLock};
use std::thread;

fn main() {
    let data = Arc::new(RwLock::new(vec![1, 2, 3]));

    let readers: Vec<_> = (0..3)
        .map(|i| {
            let data = Arc::clone(&data);
            thread::spawn(move || {
                let d = data.read().unwrap();
                println!("Reader {}: {:?}", i, *d);
            })
        })
        .collect();

    let writer = thread::spawn(move || {
        let mut d = data.write().unwrap();
        d.push(4);
        println!("Writer: {:?}", *d);
    });

    for reader in readers {
        reader.join().unwrap();
    }
    writer.join().unwrap();
}

原子操作实战

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

fn main() {
    let counter = Arc::new(AtomicUsize::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            for _ in 0..1000 {
                counter.fetch_add(1, Ordering::SeqCst);
            }
        });
        handles.push(handle);
    }

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

    println!("Result: {}", counter.load(Ordering::SeqCst));
}

实际业务场景

场景一:并行数据处理

use std::thread;

fn process_chunk(chunk: Vec<i32>) -> Vec<i32> {
    chunk.into_iter().map(|x| x * 2).collect()
}

fn main() {
    let data = vec![1, 2, 3, 4, 5, 6, 7, 8];
    let chunk_size = data.len() / 4;
    
    let mut handles = vec![];
    
    for i in 0..4 {
        let start = i * chunk_size;
        let end = if i == 3 { data.len() } else { (i + 1) * chunk_size };
        let chunk = data[start..end].to_vec();
        
        let handle = thread::spawn(move || process_chunk(chunk));
        handles.push(handle);
    }
    
    let mut results = vec![];
    for handle in handles {
        let result = handle.join().unwrap();
        results.extend(result);
    }
    
    println!("Results: {:?}", results);
}

场景二:工作池模式

use std::sync::mpsc;
use std::thread;

struct Worker {
    id: usize,
    thread: Option<thread::JoinHandle<()>>,
}

impl Worker {
    fn new(id: usize, receiver: mpsc::Receiver<Job>) -> Self {
        let thread = thread::spawn(move || loop {
            let job = receiver.recv();
            match job {
                Ok(job) => {
                    println!("Worker {} executing job", id);
                    job();
                }
                Err(_) => {
                    println!("Worker {} disconnected", id);
                    break;
                }
            }
        });
        
        Worker {
            id,
            thread: Some(thread),
        }
    }
}

type Job = Box<dyn FnOnce() + Send + 'static>;

struct ThreadPool {
    workers: Vec<Worker>,
    sender: mpsc::Sender<Job>,
}

impl ThreadPool {
    fn new(size: usize) -> Self {
        let (sender, receiver) = mpsc::channel();
        let receiver = std::sync::Arc::new(std::sync::Mutex::new(receiver));
        
        let mut workers = Vec::with_capacity(size);
        for id in 0..size {
            workers.push(Worker::new(id, std::sync::Arc::clone(&receiver)));
        }
        
        ThreadPool { workers, sender }
    }
    
    fn execute<F>(&self, f: F)
    where
        F: FnOnce() + Send + 'static,
    {
        self.sender.send(Box::new(f)).unwrap();
    }
}

fn main() {
    let pool = ThreadPool::new(4);
    
    for i in 0..8 {
        pool.execute(move || {
            println!("Processing task {}", i);
        });
    }
}

性能优化

使用scoped threads

use std::thread;

fn main() {
    let mut arr = vec![1, 2, 3, 4];
    
    thread::scope(|s| {
        for i in 0..arr.len() {
            s.spawn(move || {
                arr[i] *= 2;
            });
        }
    });
    
    println!("{:?}", arr);
}

使用rayon进行并行迭代

use rayon::prelude::*;

fn main() {
    let mut arr = vec![1, 2, 3, 4, 5];
    
    arr.par_iter_mut().for_each(|x| *x *= 2);
    
    println!("{:?}", arr);
}

总结

Rust的并发编程能力非常强大,通过所有权系统在编译时保证并发安全。从Python开发者的角度来看,Rust的并发模型更加严谨和安全,但学习曲线较陡。

在实际项目中,建议根据业务场景选择合适的并发原语,并注意性能优化和代码可读性。

YOLOv8 置信度阈值 (conf) 和 IoU 阈值 (iou) 详解:如何平衡漏检与误检? 摘要 本文深入探讨了YOLOv8目标检测模型中两个关键参数——置信度阈值(conf)和IoU阈值(iou)的核心作用。文章从目标检测的基础概念出发,解释了置信度分数反映模型预测可靠性,IoU衡量预测框重叠程度。重点剖析了非极大值抑制(NMS)机制如何通过这两个阈值进行预测框筛选:置信度阈值作为初筛门槛,IoU阈值决定重叠框的取舍。通过生动比喻和可视化图表,阐述了合理调节这两个参数能有效平衡误检与漏检问题,是优化YOLOv8模型实际表现的重要技巧。全文以实践为导向,帮助开发者掌握成为"调参大师&qu 阅读详情

相关推荐

富芮坤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的博客 4324

【Rust通道】消息在飞翔:Rust通道机制深度揭秘

Rust 中的通道 (channel) 是一种用于不同线程之间传递消息的机制。主要有以下几个特点: • 通道提供了一种在线程之间安全传递数据的方式。向通道发送数据不会导致竞争条件或死锁。 通道运用了 Rust 的所有权系统来确保消息只被一个接收者获取。当一个值通过通道发送时, 发送者会失去这个值的所有权。 • 通道可以设置为同步的或异步的。同步通道在没有接收者准备好时会阻塞发送者。异步通道则会在后台缓冲未处理的消息。

景天科技苑 2万+

华为手环实时心率数据导出到UWP项目中

hello大家好呀O(∩_∩)O最近在做毕设 其中有个小功能要用到实时心率数据。查找网上的资料发现只有小米手环的实时心率数据导出但是没有华为手环的,我试了华为手环但是并不能行得通哈哈哈。现在分享一下华为手环实时心率数据导出的代码。

apple_63713858的博客 1585

从零构建线程安全应用,Rust并发模型深度解析

掌握Rust并发安全核心原理,从零构建高可靠多线程应用。深入解析所有权与借用机制如何保障线程安全,涵盖Arc、Mutex等同步工具的实际应用场景与性能优势,助你规避数据竞争。值得收藏的Rust并发模型深度指南,点击了解实现高效安全并发的完整方法。

FuncTide的博客 933

ATAC-seq数据分析流程

Outline0. ATAC-seq原理0.1 染色体结构0.2 原理0.3 结果0.4 意义1. ATAC-seq数据分析流程1.1 上游分析(1)序列质控和比对(2)序列筛选1.2 下游分析1.3 进阶分析 0. ATAC-seq原理 0.1 染色体结构 0.2 原理 0.3 结果 0.4 意义 1. ATAC-seq数据分析流程 1.1 上游分析 (1)序列质控和比对 fastqc trim_golare bowtie2 mapping时要加上参数 --very-sensitive -X 2000

weixin_57830892的博客 1万+

LVGL仪表盘实战:5分钟用lv_meter打造汽车仪表UI(附完整代码)

本文详细介绍了如何使用LVGL的lv_meter组件在5分钟内构建专业汽车仪表盘UI。从环境配置、刻度定制到指针动画和性能优化,提供完整代码示例和实战技巧,帮助开发者快速实现嵌入式设备上的高效仪表盘设计。

k5l6m的博客 428

Rust 异步通道原理与实践深度解析

更重要的是,不同的通道选择直接影响并发逻辑的清晰度——使用 oneshot 明确表达"单次信号"的语义,代码意图更鲜明,维护者也更容易理解系统设计。发送端(Sender)可以被克隆到多个并发任务中,每个发送者都能独立地投递消息,而接收端(Receiver)必须唯一(遵循 Rust 的所有权原则)。在分布式并发编程中,Rust 的异步通道是实现 Actor 模式和消息传递并发的基础设施。这避免了内存无限增长的风险,是背压(backpressure)在异步系统中的优雅体现。接收端拥有对通道状态的完全观察权。

居然天上楼的博客 954

Dify工作流实践—根据word需求文档编写测试用例到Excel中

文章介绍了用dify工作流实现从word需求文档到测试用例写入excel的详细落地过程

weixin_42476668的博客 5336

RustMark v0.7:并发渲染引擎 — Rust 线程、通道与线程安全深度实战

核心痛点:当 Markdown 编辑器加载超过 10 万行的文档时,单线程渲染管线在主线程上执行语法高亮、AST 遍历、CSS 样式计算和布局排版,导致 UI 冻结 2-5 秒,用户体验急剧下降。本文解决的核心问题是:如何利用 Rust 的所有权系统和并发原语,构建一个线程安全、无数据竞争的并行渲染引擎。前置知识:需要掌握 Rust 所有权、借用、生命周期基础(入门篇第 2 篇),以及枚举、模式匹配和错误处理(入门篇第 3 篇)。系列阶段:进阶篇 第 3 篇(总第 8 篇),属于引擎构建阶段。

我的博客 340

告别F5失灵!手把手教你为Cursor配置.Net Core控制台项目专属调试环境

本文详细指导如何在Cursor编辑器中为.Net Core控制台项目配置专属调试环境,解决F5失灵等常见问题。从调试器选择到launch.json配置,再到高级调试技巧,帮助开发者高效搭建完整的调试工具链,提升开发效率。

weixin_28834765的博客 288

Docker Desktop 从 C 盘迁移到 D 盘的正确方法

本文介绍了三种将Docker数据目录从C盘迁移到D盘的方案。方案1针对WSL2用户,通过导出/导入虚拟磁盘实现迁移;方案2采用软链接方式,适合所有Docker模式;方案3则建议重装Docker到D盘。其中WSL2迁移方案(方案1)最为稳定可靠,推荐使用。文章详细说明了各方案的操作步骤及注意事项,并提供了迁移后常见问题的解决方法,帮助用户彻底解决Docker占用C盘空间的问题。

sg_knight的专栏 2178

Rust并发编程实战:程序员节限时揭秘无锁编程核心秘诀

掌握Rust并发编程核心技巧,解决多线程数据竞争难题。结合rust程序员节特别分享,深入无锁编程实现原理,涵盖原子操作、共享状态管理与性能优化策略,提升系统安全与效率,值得收藏。

FastSolve的博客 728

元学习与Transformer的结合:Meta-Transformer架构解析

我们生活在一个信息爆炸的时代,每天都会产生海量的数据。在深度学习领域,如何让模型更高效地学习、更快地适应新的任务,一直是科学家们努力的方向。元学习和Transformer都是深度学习中的重要概念,它们各自有着独特的优势。本文的目的就是深入剖析将元学习和Transformer结合起来的Meta - Transformer架构,探讨它的原理、应用以及未来发展。我们会从基础概念讲起,逐步深入到架构的各个方面,让大家对Meta - Transformer有一个全面的了解。

AI智能探索者的博客 1055

Rust异步通道深度解析:mpsc与oneshot的原理与实践

异步通道是Rust异步编程的基础设施,mpsc和oneshot作为两种最常用的通道类型,分别解决了多对一通信和一对一单次通信的问题。通过深入理解其设计原理和实现细节,开发者可以构建出更高效、更安全的异步系统。mpsc通道的多生产者协作模式及其在任务调度中的应用oneshot通道的单次通信特性及其在请求-响应模式中的应用通道与异步运行时的协同工作机制各种高级特性和最佳实践未来,随着异步 Rust 生态的不断发展,通道实现将在性能和功能上持续优化。更智能的负载均衡算法。

2402_89524794的博客 414

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

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

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

异步与并发全解析,Rust线程模型深度剖析及性能优化策略

掌握Rust线程用法,深入解析异步与并发编程模型。涵盖多线程管理、所有权机制规避数据竞争、async/await异步实践及性能优化策略,适用于高并发网络服务与系统级开发。内容详实,值得收藏。

VarLens的博客 924

老版QQ原生表情gif动态

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

Rust 并发编程的另一种范式:Actix Actor 模型深度实践

本文深入探讨了 Rust 中 Actor 模型的应用,重点介绍了 Actix 框架的核心架构和实践方法。文章首先对比了共享内存并发与消息传递并发的差异,指出 Actor 模型通过封装状态和强制消息传递来消除锁的需求。核心部分解析了 Actor、Context 和 Handler 三个关键概念,并通过实际代码示例展示了如何构建有状态的异步工作流和使用 SyncArbiter 处理阻塞操作。最后,文章分析了 Actor 模型的适用场景,强调其在复杂状态管理、周期控制和隔离阻塞操作方面的优势,同时指出简单并发场景

超哥的博客 825

蓝牙模块HM-10手册

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

Rust 异步通道深度解析:mpsc 与 oneshot 的原理与实践

在 Rust 的异步生态中,通道(Channel)是实现任务间通信的核心抽象。与传统的共享内存模型不同,Rust 通过"通过通信来共享内存"的理念,利用所有权系统在编译期保证并发安全。异步通道在此基础上进一步解决了异步上下文中的数据传递问题,其核心在于将阻塞操作转换为可被异步运行时调度的 Future。mpsc(multiple producer, single consumer)和 oneshot 是两种典型的异步通道模式。mpsc 允许多个生产者向单一消费者发送消息,适用于工作队列、事件分发等场景;

weixin_46751997的博客 592

你真的懂Rust的send和recv吗?深度剖析通道所有权转移的安全机制

掌握Rust通道通信核心机制,深入解析send与recv的所有权转移原理。涵盖多线程场景下的安全传递、消息队列应用及零拷贝优势,避免数据竞争。理解Move语义如何保障通信安全,值得收藏。

FastProceed的博客 992

Rust 异步通道:从 Waker 协议到系统设计的深度解析

Rust 的异步通道(Channels)是任务间通信的基石,其设计深度融合了所有权系统与PollWaker异步模型。与不同,异步通道的send和recv操作本身是async函数。这意味着它们在无法立即完成时(如通道已满或已空)会非阻塞地让出执行权,而不是阻塞操作系统线程。这一切的核心是Waker协议。当一个任务而通道为空时,recv的poll方法会返回,并将当前任务的Waker注册到通道的等待者列表中。当另一个任务数据时,它不仅将数据放入缓冲区,还会wake()。

qq_63306561的博客 468

Rust语言所有权系统与并发编程深度解析

可变引用(`&mut T`)则附加了更严格的规则:在特定作用域内,对特定数据只能存在一个可变引用,且不能与不可变引用共存。它是一套深刻的类型哲学,通过编译期的严格规则,将内存安全、数据竞争预防等传统上依赖于运行时和开发者经验的沉重负担,转化为可验证的编译期约束。从单一所有权到借用检查,再到`Send`/`Sync`,Rust构建了一条从内存安全通向并发安全的清晰路径。`Sync`表示类型的引用可以安全地在多个线程间共享。其核心创新——所有权系统,不仅是内存管理的基石,更是其安全并发编程模型的根本所在。

snohia_469的博客 169

【Rust并发编程必修课】:深入理解mpsc、oneshot与bounded通道的底层原理

掌握Rust通道通信机制,深入解析mpsc、oneshot与bounded通道的底层原理及适用场景,提升并发编程效率。涵盖线程间安全通信的核心方法与性能优势,助你构建高效可靠的应用,值得收藏。

LearnFlow的博客 858

深入理解 Rust 异步通道:mpsc 与 oneshot 的原理与实践(深度详解版)

Rust 的异步通道不仅是语法糖,其背后是精心设计的状态机、无锁数据结构和高效的事件通知机制。只有深入理解其工作原理,才能在复杂系统中做出正确的架构决策。在实践中,应结合性能分析工具(如)持续优化,确保系统在高负载下依然稳定高效。

小二丶的博客 922

Rust 线程安全保证:Send 与 Sync 的深度解读

在并发编程领域,“线程安全”是一个沉重的话题,它通常与数据竞争(Data Races)、死锁和难以复现的 Bug 相关联。传统语言(如 C/C++)将线程安全的重担完全交给开发者,依赖于开发者的自律和复杂的锁机制。Rust 则从一个根本不同的哲学出发:线程安全是一种类型系统属性,必须在编译时被证明,而不是在运行时去祈祷。 这一保证的核心基石,就是 和 这两个 marker trait。在 Rust 中, 和 不是普通的 trait;它们是标记特质(marker traits)。它们没有任何需要实现的方

caicaibucai111的博客 550

【Rust信号量实现深度解析】:掌握并发编程核心技能的5个关键步骤

掌握Rust信号量实现,轻松应对多线程资源竞争问题。本文详解其在并发控制中的应用场景与核心实现机制,涵盖Arc、Mutex配合使用技巧,提升程序稳定性与性能。深入浅出,适合中高级开发者进阶学习,值得收藏。

QuickSolve的博客 623

终极Rust学习指南:Comprehensive Rust核心概念与实战解析

Comprehensive Rust 是由 Google Android 团队打造的权威 Rust 课程,旨在帮助开发者快速掌握这门系统级编程语言的核心概念与实战技巧。本指南将带你深入探索这门课程的精华内容,从基础语法到高级特性,从内存管理到并发编程,全方位提升你的 Rust 编程能力。 ## 为什么选择 Comprehensive Rust? Rust 作为一门注重安全、性能和并发的系统编程

gitblog_00778的博客 892

Rust 异步并发基石:异步锁(Mutex、RwLock)的设计与深度实践

Rust异步生态中,Mutex和RwLock是保护共享状态的关键工具。异步锁与同步锁在设计哲学上存在本质差异:同步锁通过线程阻塞实现,而异步锁通过任务让出实现。本文深入分析了标准库锁与Tokio异步锁的核心区别,探讨了同步锁在异步代码中的死锁风险与Send约束问题,并提供了锁分片、读写锁优化等高级实践模式。文章强调"无锁>通道>锁"的优先级原则,指出异步锁虽强大但需谨慎使用,掌握其边界与底层原理是成为Rust资深开发者的关键。

超哥的博客 1055
上一篇: Rust内存安全:所有权、借用与生命周期深度解析
下一篇: Rust异步运行时:Tokio深度解析与实战
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值