Rust 智能指针的使用详解

2025-09-25 00:50
文章标签 rust 指针 使用 详解 智能

本文主要是介绍Rust 智能指针的使用详解，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《Rust智能指针的使用详解》Rust智能指针是内存管理核心工具,本文就来详细的介绍一下Rust智能指针（Box、Rc、RefCell、Arc、Mutex、RwLock、Weak）的原理与使用场景,...

一、Rust 智能指针详解

智能指针是Rust中管理内存和所有权的核心工具，通过封装指针并添加元数据（如引用计数）来实现安全的内存管理。以下是主要类型及其原理、使用场景和示例：

Rust 智能指针的使用详解

1、Box<T>：堆内存分配

  • 原理：在堆上分配内存，栈中存储指向堆的指针。所有权唯一，离开作用域时自动释放内存。
  • 使用场景：
    • 编译时未知大小的类型（如递归类型）
    • 转移大数据所有权避免拷贝
    • 特质对象（Trait Object）的动态分发
  • 示例：
    fn main() {
    let b = Box::new(5); // 在堆上存储整数5
    println!("b = {}", b); // 输出: b = 5
} // 离开作用域，堆内存自动释放

2、Rc<T>：引用计数指针

  • 原理：通过引用计数跟踪值的所有者数量。当计数归零时自动释放内存。仅适用于单线程。
  • 使用场景：多个部分只读共享数据（如图结构、共享配置）。
  • 示例：
    use std::rc::Rc;
fn main() {
    let a = Rc::new(10);
    let b = Rc::clone(&a); // 引用计数+1
    println!("Count: {}", Rc::strong_count(&a)); // 输出: Count: 2
} // 离开作用域，计数归零，内存释放

3、RefCell<T>：内部可变性

  • 原理：在运行时检查借用规则（而非编译时），允许通过不可变引用修改内部数据。使用borrow()和borrow_mut()访问。
  • 使用场景：需要修改只读共享数据时（如缓存更新）。
  • 示例：
    use std::cell::RefCell;
fn main() {
    let c = RefCell::new(42);
    *c.borrow_mut() += 1; // 运行时借用检查
    println!("c = {}", c.borrow()); // 输出: c = 43
}

4、Arc<T>：原子引用计数

  • 原理：类似Rc<T>，但使用原子操作保证线程安全。性能略低于Rc。
  • 使用场景：多线程共享数据（需配合Mutex）。
  • 示例：
    use std::sync::Arc;
use std::thread;
fn main() {
    let val = Arc::new(100);
    let handle = thread::spawn(move || {
        println!("ThreadChina编程: {}", val); // 安全共享
    });
    handle.join().unwrap();
}

5、Mutex<T>与RwLock<T>：线程同步

  • Mutex<T>：互斥锁，一次仅允许一个线程访问数据。 
    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 c = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = c.lock().unwrap();
            *num += 1; // 修改受保护数据
        });
        handles.push(handle);
    }
    for handle in handles { handle.join().unwrap(); }
    println!("Result: {}", *counter.lock().unwrap()); // 输出: Result: 10
}
  • RwLock<T>：读写锁，允许多个读取或单个写入。
    use std::sync::RwLock;
let lock = RwLock::new(5);
{
    let r1 = lock.read().unwrap(); // 多个读取并发
    let r2 = lock.read().unwrap();
}
{
    let mut w = lock.write().unwrap(); // 独占写入
    *w += 1;
}

6、Weak<T>：解决循环引用

  • 原理：Weak 是 Rc 的非拥有智能指针，它不增加引用计数。
  • 使用场景：用于解决循环引用问题
  • 示例：
    use std::rc::{Rc, Weak};
use std::cell::RefCell;

// 定义节点结构
struct Node {
    value: i32,
    parent: RefCell<Weak<Node>>, // 使用 Weak 避免循环引用
    children: RefCell<Vec<Rc<Node>>>, // 子节点使用 Rc
}

fn main() {
    // 创建叶子节点
    let leaf = Rc::new(Node {
        value: 3,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![]),
    });

    // 创建分支节点，并设置 leaf 为其子节点
    let branch = Rc::new(Node {
        value: 5,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![Rc::clone(&leaf)]),
    });

    // 设置 leaf 的父节点为 branch（使用 downgrade 创建弱引用）
    *leaf.parent.borrow_mut() = Rc::downgrade(&branch);

    // 尝试升级 leaf 的父节点
    if let Some(parent) = leaf.parent.borrow().upgrade() {
        println!("Leaf 的父节点值: {}", parent.value); // 输出: Leaf 的父节点值: 5
    } else {
        println!("父节点已被释放");
    }

    // 当 branch 被丢弃时，leaf 的 parent 升级会失败
}

7、组合模式

  • Rc<RefCell<T>>：单线程内共享可变数据。 
    let shared_data = Rc::new(RefCell::new(vec![1, 2]));
shared_data.borrow_mut().push(3); // 修改共享数据
  • Arc<Mutex<T>>：多线程共享可变数据（最常见组合）。
    let data = Arc::new(Mutex::new(0));
// 多线程修改数据（见上文Mutex示例）

8、对比总结

类型线程安全可变性适用场景
Box<T>❌所有权唯一堆分配、递归类型
Rc<T>❌不可变共享单线程共享只读数据
RefCell<T>❌内部可变单线程运行时借用检查
Arc<T>✅不可变共享多线程共享只读数据
Mutex<T>✅线程安全可变多线程互斥修改数据
RwLock<T>✅读写分离读多写少场景

二、Rust 智能指针示例

以下是一个复杂的 Rust 智能指针示例，结合了 Rc、RefCell 和自定义智能指针，模拟图形渲染场景中的资源管理：

use std::rc::{Rc, Weak};
use std::cell::RefCell;
use std::ops::Deref;

// 自定义智能指针：带引用计数的纹理资源
struct Texture {
    id: u32,
    data: Vec<u8>,
}

impl Texture {
    fn new(id: u32, size: usize) -> Self {
        Texture {
            id,
            data: vec![0; size],
        }
    }
}

// 自定义智能指针：TextureHandle
struct TextureHandle(Rc<Texture>);

impl TextureHandle {
    fn new(texture: Texture) -> Self {
        TextureHandle(Rc::new(texture))
    }
    
    fn phpget_id(&self) -> u32 {
        self.0.id
    }
}

impl Deref for TextureHandle {
    type Target = Texture;
    
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

// 场景节点：支持父子关系
struct SceneNode {
    name: String,
    texture: Option<TextureHandle>,
    children: RefCell<Vec<Rc<RefCell<SceneNode>>>>,
    parent: RefCell<Weak<RefCell<SceneNode>>>,
}

impl SceneNode {
    fn new(name: &str) -> Rc<RefCell<Self>> {
        Rc::new(RefCell::new(SceneNode {
            name: name.to_string(),
            texture: None,
            children: RefCell::new(Vec::new()),
            parent: RefCell::new(Weak::new()),
        }))
    }
    
    fn add_child(parent: &Rc<RefCell<SceneNode>>, child: &Rc<RefCell<SceneNode>>) {
        child.borrow_mut().parent.replace(Rc::downgrade(parent));
        parent.borrow_mut().children.borrow_mut().push(Rc::clone(child));
    }
    
    fn set_texture(&mut self, texture: TextureHandle) {
        self.texture = Some(texture);
    }
    
    fn print_tree(&self, depth: usize) {
        let indent = "  ".repeat(depth);
        println!("{}{}", indent, self.name);
        if let Some(tex) = &self.texture {
            println!("{}Texture ID: {}", indent, tex.get_id());
        }
        for child in self.children.borrow().iter() {
            child.borrow().print_tree(depth + 1);
        }
    }
}

fn main() {
    // 创建共享纹理资源
    let shared_texture = TextureHandle::new(Texture::new(101, 1024));
    
    // 创建场景节点
    let root = SceneNode::new("Root");
    let camera = SceneNode::new("Camera");
    let mesh1 = SceneNode::new("Mesh1");
    let mesh2 = SceneNode::new("Mesh2");
    
    // 设置纹理
    {
        let mut root_mut = root.borrow_mut();
        root_mut.set_texture(shared_texture);
    }
    
    // 构建场景层级
    SceneNode::add_child(&root, &camera);
    SceneNode::add_child(&root, &mesh1);
    SceneNode::add_child(&mesh1, &mesh2);
    
    // 打印场景树
    root.borrow().print_tree(0);
    
    // http://www.chinasem.cn验证引用计数
    println!("\nReference counts:");
    println!("Root strong: {}", Rc::strong_count(&root));
    println!("Root weak: {}", Rc::weak_count(&root));
}

示例解析：

  1. 自定义智能指针 phpTextureHandle

    • 包装 Rc<Texture> 实现资源共享
    • 实现 Deref 获得透明访问
    • 提供资源 ID 访问方法

  2. 场景图管理 SceneNode

    • 使用 Rc<RefCell<SceneNode>> 实现共享所有权和内部可变性
    • 子节点列表：RefCell<Vec<Rc<...>>> 实现运行时可变借用
    • 父节点：RefCell<Weak<...>> 避免循环引用

  3. 资源共享机制

    • 纹理资源通过 TextureHandle 共享
    • 节点树通过 Rc 共享所有权
    • 使用 Weak 引用打破循环依赖

  4. 输出示例：

Root
Texture ID: 101
  Camera
  Mesh1
    Mesh2

Reference counts:
Root strong: 1
Root weak: 2
PS G:\Learning\Rust\ttt>

Rust 智能指针的使用详解

关键特性：

  1. 内存安全：自动管理资源释放
  2. 内部可变性：通过 RefCell 修改不可变引用
  3. 循环引用防护：Weak 指针避免内存泄漏
  4. 透明访问：通过 Deref 实现直接访问
  5. 运行时借用检查：RefCell 在运行时验证借用规则

到此这篇关于Rust 智能指针的使用详解的文章就介绍到这了,更多相关Rust 智能指针内容请搜索China编程(www.chinasem.cn)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程China编程(www.chinasem.cn)！

这篇关于Rust 智能指针的使用详解的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1156015。

相关文章

Java中流式并行操作parallelStream的原理和使用方法

Java中流式并行操作parallelStream的原理和使用方法

《Java中流式并行操作parallelStream的原理和使用方法》本文详细介绍了Java中的并行流（parallelStream）的原理、正确使用方法以及在实际业务中的应用案例,并指出在使用并行流... 目录Java中流式并行操作parallelStream0. 问题的产生1. 什么是parallelS
阅读更多...
MySQL数据库双机热备的配置方法详解

MySQL数据库双机热备的配置方法详解

《MySQL数据库双机热备的配置方法详解》在企业级应用中,数据库的高可用性和数据的安全性是至关重要的,MySQL作为最流行的开源关系型数据库管理系统之一,提供了多种方式来实现高可用性,其中双机热备（M... 目录1. 环境准备1.1 安装mysql1.2 配置MySQL1.2.1 主服务器配置1.2.2 从
阅读更多...
Linux join命令的使用及说明

Linux join命令的使用及说明

《Linuxjoin命令的使用及说明》`join`命令用于在Linux中按字段将两个文件进行连接,类似于SQL的JOIN,它需要两个文件按用于匹配的字段排序,并且第一个文件的换行符必须是LF,`jo... 目录一. 基本语法二. 数据准备三. 指定文件的连接key四.-a输出指定文件的所有行五.-o指定输出
阅读更多...
Linux jq命令的使用解读

Linux jq命令的使用解读

《Linuxjq命令的使用解读》jq是一个强大的命令行工具,用于处理JSON数据,它可以用来查看、过滤、修改、格式化JSON数据,通过使用各种选项和过滤器,可以实现复杂的JSON处理任务... 目录一. 简介二. 选项2.1.2.2-c2.3-r2.4-R三. 字段提取3.1 普通字段3.2 数组字段四.
阅读更多...
Linux kill正在执行的后台任务 kill进程组使用详解

Linux kill正在执行的后台任务 kill进程组使用详解

《Linuxkill正在执行的后台任务kill进程组使用详解》文章介绍了两个脚本的功能和区别,以及执行这些脚本时遇到的进程管理问题,通过查看进程树、使用`kill`命令和`lsof`命令,分析了子... 目录零. 用到的命令一. 待执行的脚本二. 执行含子进程的脚本，并kill2.1 进程查看2.2 遇到的
阅读更多...
MyBatis常用XML语法详解

MyBatis常用XML语法详解

《MyBatis常用XML语法详解》文章介绍了MyBatis常用XML语法,包括结果映射、查询语句、插入语句、更新语句、删除语句、动态SQL标签以及ehcache.xml文件的使用,感兴趣的朋友跟随小... 目录1、定义结果映射2、查询语句3、插入语句4、更新语句5、删除语句6、动态 SQL 标签7、ehc
阅读更多...
详解SpringBoot+Ehcache使用示例

详解SpringBoot+Ehcache使用示例

《详解SpringBoot+Ehcache使用示例》本文介绍了SpringBoot中配置Ehcache、自定义get/set方式,并实际使用缓存的过程,文中通过示例代码介绍的非常详细,对大家的学习或者... 目录摘要概念内存与磁盘持久化存储：配置灵活性：编码示例引入依赖：配置ehcache.XML文件：配置
阅读更多...
Java 虚拟线程的创建与使用深度解析

Java 虚拟线程的创建与使用深度解析

《Java虚拟线程的创建与使用深度解析》虚拟线程是Java19中以预览特性形式引入,Java21起正式发布的轻量级线程,本文给大家介绍Java虚拟线程的创建与使用,感兴趣的朋友一起看看吧... 目录一、虚拟线程简介1.1 什么是虚拟线程？1.2 为什么需要虚拟线程？二、虚拟线程与平台线程对比代码对比示例：三
阅读更多...
从基础到高级详解Go语言中错误处理的实践指南

从基础到高级详解Go语言中错误处理的实践指南

《从基础到高级详解Go语言中错误处理的实践指南》Go语言采用了一种独特而明确的错误处理哲学,与其他主流编程语言形成鲜明对比,本文将为大家详细介绍Go语言中错误处理详细方法,希望对大家有所帮助... 目录1 Go 错误处理哲学与核心机制1.1 错误接口设计1.2 错误与异常的区别2 错误创建与检查2.1 基础
阅读更多...
k8s按需创建PV和使用PVC详解

k8s按需创建PV和使用PVC详解

《k8s按需创建PV和使用PVC详解》Kubernetes中,PV和PVC用于管理持久存储,StorageClass实现动态PV分配,PVC声明存储需求并绑定PV,通过kubectl验证状态,注意回收... 目录1.按需创建 PV（使用 StorageClass）创建 StorageClass2.创建 PV
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2