Rust并发安全模式:从线程同步到无锁编程

Rust语言的多线程编程 Rust是一种系统级编程语言,以其内存安全和并发编程的优势而闻名。在当今的计算密集型和高并发的场景中,良好的多线程编程能力显得尤为重要。Rust通过内存安全和避免数据竞争的特性,使得编程者在进行多线程开发时更加高效和安全。本文将深入探讨Rust语言的多线程编程,包括其基本概念、常用工具、示例代码以及最佳实践。 阅读详情

Rust并发安全模式:从线程同步到无锁编程

引言

并发安全是Rust最引人注目的特性之一。作为从Python转向Rust的后端开发者,我深刻体会到Rust在编译时保证线程安全的独特优势。Rust的所有权系统消除了数据竞争的可能性,让并发编程变得更加安全和高效。本文将深入探讨Rust的并发安全模式,帮助你编写可靠的并发代码。

一、并发安全基础

1.1 数据竞争问题

数据竞争发生在以下条件同时满足时:

  1. 多个线程访问同一数据
  2. 至少有一个线程写入数据
  3. 没有足够的同步机制

1.2 Rust的解决方案

Rust通过所有权系统在编译时防止数据竞争:

  • 所有权规则:每个值只能有一个所有者
  • 借用规则:可变引用和不可变引用不能同时存在
  • 生命周期:确保引用的有效性

二、线程同步原语

2.1 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());
}

2.2 RwLock

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

fn main() {
    let data = Arc::new(RwLock::new(vec![1, 2, 3]));
    
    // 多个读操作可以同时进行
    for i in 0..3 {
        let data = Arc::clone(&data);
        thread::spawn(move || {
            let read = data.read().unwrap();
            println!("Reader {}: {:?}", i, *read);
        });
    }
    
    // 写操作独占访问
    let data = Arc::clone(&data);
    thread::spawn(move || {
        let mut write = data.write().unwrap();
        write.push(4);
        println!("Writer: {:?}", *write);
    }).join().unwrap();
}

2.3 Condvar

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

fn main() {
    let pair = Arc::new((Mutex::new(false), Condvar::new()));
    let pair2 = Arc::clone(&pair);
    
    thread::spawn(move || {
        let (lock, cvar) = &*pair2;
        let mut started = lock.lock().unwrap();
        *started = true;
        cvar.notify_one();
    });
    
    let (lock, cvar) = &*pair;
    let mut started = lock.lock().unwrap();
    while !*started {
        started = cvar.wait(started).unwrap();
    }
    println!("Thread started");
}

三、消息传递

3.1 Channel

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);
}

3.2 多生产者

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

fn main() {
    let (tx, rx) = mpsc::channel();
    
    for i in 0..3 {
        let tx = tx.clone();
        thread::spawn(move || {
            let message = format!("Message {}", i);
            tx.send(message).unwrap();
        });
    }
    
    for received in rx {
        println!("Received: {}", received);
    }
}

3.3 crossbeam-channel

use crossbeam_channel as channel;
use std::thread;

fn main() {
    let (snd, rcv) = channel::unbounded();
    
    thread::spawn(move || {
        snd.send(42).unwrap();
    });
    
    println!("Received: {}", rcv.recv().unwrap());
}

四、无锁编程

4.1 Atomic类型

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

fn main() {
    let counter = AtomicUsize::new(0);
    let mut handles = vec![];
    
    for _ in 0..10 {
        let handle = thread::spawn(move || {
            counter.fetch_add(1, Ordering::SeqCst);
        });
        handles.push(handle);
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    println!("Result: {}", counter.load(Ordering::SeqCst));
}

4.2 原子引用计数

use std::sync::Arc;
use std::thread;

fn main() {
    let data = Arc::new(vec![1, 2, 3]);
    
    for _ in 0..5 {
        let data = Arc::clone(&data);
        thread::spawn(move || {
            println!("Data: {:?}", data);
        });
    }
}

4.3 CAS操作

use std::sync::atomic::{AtomicI32, Ordering};

fn compare_and_swap_example() {
    let value = AtomicI32::new(5);
    
    // 尝试将5替换为10
    let result = value.compare_and_swap(5, 10, Ordering::SeqCst);
    assert_eq!(result, 5); // 返回旧值
    
    // 再次尝试(当前值是10,不是5)
    let result = value.compare_and_swap(5, 20, Ordering::SeqCst);
    assert_eq!(result, 10); // 返回当前值,交换失败
}

五、并发数据结构

5.1 ConcurrentHashMap

use dashmap::DashMap;
use std::thread;

fn main() {
    let map = DashMap::new();
    
    let handles: Vec<_> = (0..10).map(|i| {
        let map = map.clone();
        thread::spawn(move || {
            map.insert(i, i * 2);
        })
    }).collect();
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    println!("Map contains {} entries", map.len());
}

5.2 ConcurrentQueue

use crossbeam::queue::SegQueue;
use std::thread;

fn main() {
    let queue = SegQueue::new();
    
    // 生产者
    thread::spawn(move || {
        for i in 0..10 {
            queue.push(i);
        }
    });
    
    // 消费者
    thread::spawn(move || {
        while let Some(val) = queue.pop() {
            println!("Got: {}", val);
        }
    }).join().unwrap();
}

六、实战:并发任务调度器

6.1 任务队列

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

struct TaskQueue {
    queue: Mutex<VecDeque<Box<dyn FnOnce() + Send>>>,
}

impl TaskQueue {
    fn new() -> Self {
        TaskQueue {
            queue: Mutex::new(VecDeque::new()),
        }
    }
    
    fn push(&self, task: Box<dyn FnOnce() + Send>) {
        self.queue.lock().unwrap().push_back(task);
    }
    
    fn pop(&self) -> Option<Box<dyn FnOnce() + Send>> {
        self.queue.lock().unwrap().pop_front()
    }
}

6.2 Worker线程

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

impl Worker {
    fn new(id: usize, queue: Arc<TaskQueue>) -> Self {
        let thread = thread::spawn(move || {
            loop {
                if let Some(task) = queue.pop() {
                    println!("Worker {} executing task", id);
                    task();
                }
            }
        });
        
        Worker {
            thread: Some(thread),
        }
    }
}

七、并发安全最佳实践

7.1 避免共享状态

// 不好:共享可变状态
fn bad_example() {
    let mut data = Arc::new(Mutex::new(vec![]));
    
    for _ in 0..10 {
        let data = Arc::clone(&data);
        thread::spawn(move || {
            let mut data = data.lock().unwrap();
            data.push(1);
        });
    }
}

// 好:使用消息传递
fn good_example() {
    let (tx, rx) = mpsc::channel();
    
    for _ in 0..10 {
        let tx = tx.clone();
        thread::spawn(move || {
            tx.send(1).unwrap();
        });
    }
}

7.2 使用线程池

use rayon::prelude::*;

fn process_data(data: Vec<i32>) -> Vec<i32> {
    data.par_iter()
        .map(|x| x * 2)
        .collect()
}

7.3 优雅关闭

use tokio::signal;

#[tokio::main]
async fn main() {
    let server = axum::Server::bind(&([127, 0, 0, 1], 3000).into())
        .serve(app.into_make_service());
    
    let graceful = server.with_graceful_shutdown(shutdown_signal());
    
    if let Err(e) = graceful.await {
        eprintln!("Server error: {}", e);
    }
}

async fn shutdown_signal() {
    let ctrl_c = async {
        signal::ctrl_c().await.expect("failed to install Ctrl+C handler");
    };
    
    #[cfg(unix)]
    let terminate = async {
        signal::unix::signal(signal::unix::SignalKind::terminate())
            .expect("failed to install signal handler")
            .recv()
            .await;
    };
    
    tokio::select! {
        _ = ctrl_c => {},
        _ = terminate => {},
    }
}

八、总结

Rust的并发安全特性通过所有权系统在编译时保证了线程安全,消除了数据竞争的可能性。通过使用线程同步原语、消息传递和无锁编程,我们可以构建高效、安全的并发应用。

关键要点:

  1. 使用Arc+Mutex:安全地共享可变数据
  2. 优先使用消息传递:避免共享状态
  3. 使用原子操作:无锁编程
  4. 使用线程池:管理线程数量
  5. 优雅关闭:正确处理系统信号

从Python转向Rust后,我发现Rust的并发编程更加安全和高效,编译时的检查大大减少了运行时错误。

延伸阅读

  • Rust官方并发编程指南
  • crossbeam库文档
  • dashmap库文档
  • 《Rust并发编程实战》书籍
148、Rust并发编程:Rayon库实践指南 《Rust并发编程:Rayon库实践指南》一文详细介绍了Rust语言的并发编程支持,特别是Rayon库的使用。文章从基本概念、基本使用、进阶使用三个方面展开,让读者了解并行与并发的区别、线程与进程的内涵、同步与异步的通信方式。同时,通过具体实例,讲解了如何使用Rayon进行并发任务执行,包括数据处理、文件读取等应用场景,以及如何使用Rayon的实用技巧,如join等待子任务完成、apply应用函数、chunks处理大数据集等。文章最后强调,Rust和Rayon提供了强大的并发编程能力,可以帮助开发者提升软件 阅读详情

相关推荐

【Rust多线程】Rust并发编程,如何轻松实现无畏并发

进程是资源分配的最小单位,线程是CPU调度的最小单位。每个进程都最少有一个线程,而这个线程就是我们常说的主线程 安全并高效的处理并发编程是 Rust 的另一个主要目标。 并发编程(Concurrent programming),代表程序的不同部分相互独立的执行,而 并行编程(parallel programming)代表程序不同部分于同时执行, 这两个概念随着计算机越来越多的利用多处理器的优势时显得愈发重要。

景天科技苑 3万+

【Rust并发集合】如何在多线程中并发安全地使用集合

集合类型是我们编程中常用的数据类型,Rust 中提供了一些集合类型,比如`Vec<T>`、`HashMap<K, V>`、`HashSet<T>`、`VecDeque<T>`、`LinkedList<T>`、`BTreeMap<K,V>`、`BTreeSet<T>` 等。 要实现线程安全的 Vec,可以使用 Arc(原子引用计数)和 Mutex(互斥锁)的组合。 Arc 允许多个线程共享拥有相同数据的所有权,而 Mutex 用于在访问数据时进行同步,确保只有一个线程能够修改数据。

景天科技苑 2万+

Rust并发编程:解锁高性能系统的密钥

本文聚焦 Rust 并发编程高级进阶内容,先解析并发与并行的概念及区别,阐述 Rust 在并发编程上的优势。接着讲解线程创建、生命周期、线程间通信,以及共享数据的同步机制如 Arc、Mutex 等。还深入探讨异步编程的语法、Future 特质等,介绍线程池、无锁并发等高级模式与实际案例。通过系统梳理,帮助开发者掌握 Rust 并发编程要点,助力构建高性能系统,为应对复杂并发场景提供思路与方法。

邓邓子的博客 1244

Rust并发编程实践:10分钟入门系统级编程

Rust并发编程实践:10分钟入门系统级编程

异构算力老群群(在读985计算机博士生)的技术博客 3405

【Rust 指南】并发编程|无畏并发的原因

安全高效的处理并发是 Rust 诞生的目的之一,主要解决的是服务器高负载承受能力。 并发(concurrent)的概念是指程序不同的部分独立执行,这与并行(parallel)的概念容易混淆,并行强调的是"同时执行",而并发往往会造成并行。 Rust 无畏并发:允许你编写没有细微 Bug 的代码,并在不引入新 Bug 的情况下易于重构

叶落秋白的博客 3680

用友YonSuite产品实操手把手教学(图文版)

用友YonSuite

ct341688的博客 8183

30天拿下Rust之并发

随着多核处理器和分布式系统的普及,并发编程成为了现代软件开发中不可或缺的一部分。然而,并发编程也是一项极具挑战性的任务,因为它涉及到数据共享、线程同步和竞态条件等复杂问题。在这些挑战面前,Rust以其独特的内存安全性和并发原语,为开发者提供了一个安全、高效且优雅的并发编程环境。Rust以其强大的内存安全性和丰富的并发原语,为开发者提供了一个安全、高效且优雅的并发编程环境。通过合理利用Rust的并发特性,开发者可以编写出高性能、高可靠性的并发应用程序,满足现代软件开发的需求。

hope_wisdom的技术博客 2897

从空调温控到信号降噪:一阶RC低通滤波器在Arduino和STM32上的C语言实现指南

本文详细介绍了如何在Arduino和STM32平台上使用C语言实现一阶RC低通滤波器,涵盖从基础理论到实际应用的完整流程。通过具体代码示例和优化技巧,帮助开发者有效处理传感器噪声、信号平滑等问题,提升嵌入式系统的信号处理能力。

weixin_30565199的博客 502

Rust并发编程实战-多线程武侠对战系统

摘要: 本文介绍了一个基于Rust并发编程的武侠对战项目,通过张无忌与成昆的回合制战斗,展示Rust在并发领域的三大核心优势:内存安全、高性能和并发可靠。项目采用多线程架构,包含游戏逻辑、广播和客户端处理等独立线程,使用Arc<RwLock>实现读多写少共享、Arc<Mutex>管理线程安全集合,以及类型安全的Channel通信。关键技术包括无锁设计、RAII自动锁管理、非阻塞I/O和超时机制,完美体现Rust的零成本抽象和编译时安全检查特性,为开发高性能并发系统提供了实践范例。

红目香薰 9969

Tessent_StdcellLib

第二种为 Tessent Cell lib,既可用于功能仿真,也可以用于测试逻辑插入。lib包含了用于仿真的功能信息,也包含DFT cell属性。如何使用tessent工具将stdcell verilog 仿真模型转换为tessent自己的lib。运行后工具会生成一个atpg的lib文件,打开文件,找到一个带SI的DFF,只有功能描述。tessnt lib分为两种,第一种为ATBG lib,可以用于仿真;打开生成的lib文件,多了dft_cell_selection。第二部:编写attributes文件。

qq_40411444的博客 2140

EGO-Planner文章解读(一)——论文原理和算法实现

详细解读egoplanner论文和代码

fegxg的博客 3994

【Rust线程】Rust高并发编程之线程原理解析与应用实战

Rust 标准库std::thread crate 提供了线程相关的函数。 正如上面所说,一个 Rust 程序执行的会启动一个进程,这个进程会包含一个或者多个线程, Rust 中的线程是纯操作的系统的线程,拥有自己的栈和状态。 线程之间的通讯可以通过 channel,就像 Go 语言中的 channel 的那样,也可以通过一些同步原语)。

景天科技苑 2万+

基于STM32控制直流电机加减速正反转仿真设计

*单片机设计介绍,基于STM32控制直流电机加减速正反转仿真设计。

2201_75940997的博客 1604

Rust Rosetta Code并发编程:多线程和异步任务的实战指南

Rust Rosetta Code项目提供了丰富的并发编程示例,帮助开发者掌握Rust中多线程和异步任务的实现方法。本文将通过实际案例,介绍如何在Rust中高效处理并发任务,包括多线程同步、原子操作和异步编程等核心技术。 ## 多线程基础:线程创建与资源共享 在Rust中,创建线程非常简单,通过`std::thread::spawn`函数即可启动新线程。例如,在[metered-concurr

gitblog_00651的博客 822

YOLOv11官方代码库与预训练模型下载:介绍Ultralytics官方GitHub及模型权重(yolov11n.pt, yolov11s.pt等)

本文介绍了Ultralytics官方GitHub仓库和YOLOv11预训练模型。Ultralytics仓库是YOLO系列算法的官方实现,包含YOLOv11最新代码、预训练模型、文档和工具。仓库采用清晰的代码结构和活跃的更新策略,支持全流程开发。YOLOv11提供了5种不同规模的模型变体(YOLOv11n/s/m/l/x),在精度、速度和模型大小间权衡,适用于从移动设备到高精度检测等不同场景。各模型在COCO数据集上预训练,可直接使用或微调,满足多样化应用需求。

本博客聚焦 YOLOv11 全流程落地,涵盖架构优化、数据集处理、训练技巧与多场景部署,兼及国产数据库、Java 开发与 AI 模型应用,内容兼顾理论与工程实践,为开发者提供系统干货,助力高效提升技术能力。 5840

RT-DETR改进策略【卷积层】| CGblock 内容引导网络 利用不同层次信息,提高多类别分类能力 (含二次创新)

本文记录的是利用中的模块优化的目标检测网络模型。通过局部特征提取器、周围环境提取器、联合特征提取器和全局环境提取器来提取局部特征、周围环境和全局环境信息,充分利用不同层次的信息。本文将其应用到中,并进行二次创新,使网络能够更好的处理多类别目标的分类能力。CGNet: A Light-Weight Context Guided Network for Semantic Segmentation1️⃣ 首先通过局部特征提取器floc(∗)floc(*)floc(∗)和周围环境提取器fsur(∗)f_{sur }

Limiiiing的博客 1351

Rust 并发编程

安全高效的处理并发是 Rust 诞生的目的之一,主要解决的是服务器高负载承受能力。并发(concurrent)的概念是指程序不同的部分独立执行,这与并行(parallel)的概念容易混淆,并行强调的是"同时执行"。并发往往会造成并行。本章讲述与并发相关的编程概念和细节。

m0_65541699的博客 1791

使用Open3D进行RGB-D图像点云处理

在本文中,我们将使用Open3D来处理RGB-D图像,提取点云并进行一些基本的操作。总结起来,本文介绍了如何使用Open3D库处理RGB-D图像并提取点云。我们展示了如何读取RGB-D图像,创建RGB-D图像和点云,并显示点云。除了显示点云,Open3D还提供了许多其他功能,如点云滤波、点云配准、表面重建等。在创建RGB-D图像时,我们需要指定深度图像的缩放因子和截断值,以及是否将RGB图像转换为强度图像。希望本文能够帮助您入门Open3D,并在处理RGB-D图像和点云数据时提供一些指导。

QfcaLinux的博客 448

【Rust中多线程同步机制】

Rust语言的线程间同步机制大概就这么多,需要不断的熟悉才能掌握。读写锁,信号量,条件变量,atomic,Arc

m0_37719524的博客 1754

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

Rust并发编程与多线程同步原语高级用法——构建安全高效的并发应用

本文介绍了Rust并发编程的高级主题,重点包括: 核心同步原语:详细讲解了Arc、Mutex、RwLock和Condvar的用法,通过计数器、配置共享和生产者-消费者模式等示例展示其应用场景 并发设计模式:涵盖了消息传递、共享状态两种模型,强调Rust的borrow checker如何保证并发安全 常见问题:指出了锁顺序死锁、锁粒度过大和虚假唤醒等高频错误点 代码示例:提供了多个实用代码片段,展示如何在Rust中实现线程安全的计数器、配置管理和生产者-消费者队列

编程世界如山海,探索不止。 9306

IMSL CNL 7.0.0 (x86-64)Crack

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

《Rust并发编程:掌握线程、JoinHandle和Mutex》

本文深入讲解了Rust语言中的并发编程概念,重点介绍了线程、JoinHandle和Mutex。通过生活实例和编程案例,阐述了这些概念在并发编程中的重要作用。线程实现了程序的多路径执行,JoinHandle用于异步任务同步,而Mutex则保护了共享数据的一致性。掌握这些概念对于设计和实现高效并发程序至关重要。

silenceallat的博客 1345

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

【一起学Rust | 基础篇】rust线程与并发

并发编程(Concurrent programming),指的是程序的不同部分相互独立的执行。而并行编程(parallel programming)代表程序不同部分于同时执行,这两个概念随着计算机越来越多的利用多处理器的优势时显得愈发重要。由于历史原因,在此类编程中一直是困难且容易出错的:Rust 希望能改变这一点。

专注Rust编程与技术分享,涵盖C++、Python等开发实战,新手友好,专注实战,助力编程成长。 2909

Rust的并发编程(二) 多线程并发

文章目录Rust的并发编程(二)多线程并发创建子线程线程间通信使用通道传递数据共享内存 Rust的并发编程(二) 并发,是指在宏观意义上同一时间处理多个任务。并发的方式一般包含为三种:多进程、多线程以及最近几年刚刚火起来的协程。 多线程并发 线程(thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。 创建子线程 Rust使用标准库中的thread模块创建线程: use

鸿鹄之志 1万+

Rust下的传统并发编程思路

Rust 提供了丰富且安全的传统并发编程工具,通过线程、同步原语和消息传递,开发者可以构建高性能的并发应用。Rust 的所有权系统和类型检查在编译时确保了并发代码的安全性,极大地减少了数据竞争和内存错误。结合 Rust 生态中的第三方库,开发者可以根据具体需求选择最合适的并发模型和工具,充分发挥 Rust 在并发编程中的优势。

远方雪的专栏 932

Rust 多线程编程入门:从 thread::spawn 步进入 Rust 并发世界

Rust 多线程编程入门:从 thread::spawn 步进入 Rust 并发世界这是Rust九九八十一难的第六篇。本篇聊下Rust的多线程。为了提高性能,多线程几乎在每种语言中都有应用。多线程思想是一致的,但是Rust有独特的所有权设计,还是有需要注意的地方。

taishanduba的专栏 1191
上一篇: Python装饰器深入解析:从基础到高级应用
下一篇: Rust内存管理模式:从所有权到智能指针的完整指南
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值