Rust 智能指针实战：掌握内存管理的艺术

关注

原创最新推荐文章于 2026-10-30 01:30:00 发布 4.6k 阅读 AI 写同款· GEO 优化 ›

性能巅峰对决：Rust vs C++ —— 速度、安全与权衡的艺术本文将带你深入探讨这两门语言的性能对决，剖析它们的适用场景与背后的技术权衡，通过实例代码和详尽注解，为你揭示选择它们的智慧之道。而C++，凭借其成熟的生态系统和高度灵活性，依然是游戏开发、大规模系统和高性能计算领域的首选。Rust倾向于在编译时完成尽可能多的检查和优化，这减少了运行时的开销，但也可能带来更长的编译时间。，被誉为“没有安全问题的C++”，以零代价抽象、内存安全保证和所有权系统著称，是系统编程的新星。，作为历经数十年考验的经典，凭借其灵活性、性能以及丰富的库支持，至今仍稳坐高性能计算的宝座。阅读详情

Rust 智能指针实战：掌握内存管理的艺术

智能指针的概念

智能指针是一种特殊的指针，它不仅包含指向数据的指针，还包含额外的元数据和功能。在Rust中，智能指针通常是实现了Deref和Drop trait的结构体，它们提供了更灵活的内存管理方式。

常见的智能指针

Box

Box<T>是最基本的智能指针，它将值存储在堆上，而不是栈上。

fn main() {
    // 在堆上分配一个整数
    let b = Box::new(5);
    println!("b = {}", b);
    
    // 当b离开作用域时，它所指向的堆内存会被自动释放
}

Rc

Rc<T>（Reference Counted）是一种引用计数智能指针，它允许多个所有者共享同一个值。

use std::rc::Rc;

fn main() {
    let a = Rc::new(5);
    println!("引用计数: {}", Rc::strong_count(&a));
    
    let b = Rc::clone(&a);
    println!("引用计数: {}", Rc::strong_count(&a));
    
    let c = Rc::clone(&a);
    println!("引用计数: {}", Rc::strong_count(&a));
    
    // 当a、b、c都离开作用域时，引用计数变为0，内存被释放
}

Arc

Arc<T>（Atomic Reference Counted）是一种线程安全的引用计数智能指针，它可以在多线程环境中安全使用。

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

fn main() {
    let a = Arc::new(5);
    
    let handles: Vec<_> = (0..10).map(|_| {
        let a = Arc::clone(&a);
        thread::spawn(move || {
            println!("值: {}, 引用计数: {}", *a, Arc::strong_count(&a));
        })
    }).collect();
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    println!("最终引用计数: {}", Arc::strong_count(&a));
}

RefCell

RefCell<T>是一种内部可变性的智能指针，它允许在不可变引用的情况下修改数据。

use std::cell::RefCell;

fn main() {
    let value = RefCell::new(5);
    
    {
        let mut borrow = value.borrow_mut();
        *borrow = 10;
        println!("修改后的值: {}", *borrow);
    } // borrow离开作用域，锁被释放
    
    let borrow = value.borrow();
    println!("最终值: {}", *borrow);
}

智能指针的组合使用

Rc<RefCell>

Rc<RefCell<T>>是一种常见的组合，它允许多个所有者共享同一个可变值。

use std::rc::Rc;
use std::cell::RefCell;

#[derive(Debug)]
struct Person {
    name: String,
    age: RefCell<u32>,
}

fn main() {
    let person = Rc::new(Person {
        name: "Alice".to_string(),
        age: RefCell::new(30),
    });
    
    let person1 = Rc::clone(&person);
    let person2 = Rc::clone(&person);
    
    // 修改年龄
    *person1.age.borrow_mut() += 1;
    println!("Person1: {:?}", person1);
    
    *person2.age.borrow_mut() += 1;
    println!("Person2: {:?}", person2);
    
    println!("Original: {:?}", person);
}

Arc<Mutex>

Arc<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 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!("最终计数: {}", *counter.lock().unwrap());
}

智能指针的实际应用

树结构

use std::rc::Rc;
use std::cell::RefCell;

#[derive(Debug)]
struct Node {
    value: i32,
    children: RefCell<Vec<Rc<Node>>>,
}

fn main() {
    let root = Rc::new(Node {
        value: 1,
        children: RefCell::new(vec![]),
    });
    
    let child1 = Rc::new(Node {
        value: 2,
        children: RefCell::new(vec![]),
    });
    
    let child2 = Rc::new(Node {
        value: 3,
        children: RefCell::new(vec![]),
    });
    
    root.children.borrow_mut().push(Rc::clone(&child1));
    root.children.borrow_mut().push(Rc::clone(&child2));
    
    println!("根节点: {:?}", root);
    println!("子节点1: {:?}", child1);
    println!("子节点2: {:?}", child2);
}

线程池

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

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

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

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

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

impl Worker {
    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Self {
        let thread = thread::spawn(move || {
            loop {
                let job = receiver.lock().unwrap().recv();
                match job {
                    Ok(job) => {
                        println!("Worker {} 执行任务", id);
                        job();
                    },
                    Err(_) => {
                        println!("Worker {} 收到关闭信号", id);
                        break;
                    }
                }
            }
        });
        
        Worker { id, thread }
    }
}

fn main() {
    let pool = ThreadPool::new(4);
    
    for i in 0..10 {
        pool.execute(move || {
            println!("任务 {} 执行中...", i);
            thread::sleep(std::time::Duration::from_millis(100));
            println!("任务 {} 执行完成", i);
        });
    }
    
    // 等待所有任务完成
    thread::sleep(std::time::Duration::from_secs(2));
    println!("所有任务执行完成");
}

对象池

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

struct ObjectPool<T> {
    objects: Mutex<VecDeque<T>>,
    create_object: Arc<dyn Fn() -> T + Send + Sync>,
}

impl<T> ObjectPool<T> {
    fn new<F>(size: usize, create_object: F) -> Self where F: Fn() -> T + Send + Sync + 'static {
        let mut deque = VecDeque::with_capacity(size);
        let create_object = Arc::new(create_object);
        
        for _ in 0..size {
            deque.push_back(create_object());
        }
        
        ObjectPool {
            objects: Mutex::new(deque),
            create_object,
        }
    }
    
    fn get(&self) -> PooledObject<T> {
        let mut objects = self.objects.lock().unwrap();
        
        let object = if let Some(object) = objects.pop_front() {
            object
        } else {
            // 如果池为空，创建新对象
            (self.create_object)()
        };
        
        PooledObject {
            pool: Arc::new(self),
            object: Some(object),
        }
    }
    
    fn return_object(&self, object: T) {
        let mut objects = self.objects.lock().unwrap();
        objects.push_back(object);
    }
}

struct PooledObject<T> {
    pool: Arc<ObjectPool<T>>,
    object: Option<T>,
}

impl<T> Drop for PooledObject<T> {
    fn drop(&mut self) {
        if let Some(object) = self.object.take() {
            self.pool.return_object(object);
        }
    }
}

impl<T> std::ops::Deref for PooledObject<T> {
    type Target = T;
    
    fn deref(&self) -> &Self::Target {
        self.object.as_ref().unwrap()
    }
}

impl<T> std::ops::DerefMut for PooledObject<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.object.as_mut().unwrap()
    }
}

fn main() {
    // 创建一个字符串对象池
    let pool = Arc::new(ObjectPool::new(2, || {
        println!("创建新字符串");
        String::new()
    }));
    
    { 
        let mut obj1 = pool.get();
        *obj1 = "Hello".to_string();
        println!("obj1: {}", *obj1);
    } // obj1被归还到池
    
    { 
        let mut obj2 = pool.get();
        *obj2 = "World".to_string();
        println!("obj2: {}", *obj2);
    } // obj2被归还到池
    
    { 
        let mut obj3 = pool.get();
        *obj3 = "Rust".to_string();
        println!("obj3: {}", *obj3);
    } // obj3被归还到池
    
    { 
        let mut obj4 = pool.get();
        *obj4 = "Smart Pointers".to_string();
        println!("obj4: {}", *obj4);
    } // obj4被归还到池
}

智能指针的最佳实践

1. 选择合适的智能指针

当需要在堆上分配值且只有一个所有者时，使用Box<T>
当需要多个所有者共享同一个不可变值时，使用Rc<T>
当需要多个所有者共享同一个可变值时，使用Rc<RefCell<T>>
当需要在多线程环境中共享值时，使用Arc<T>
当需要在多线程环境中共享可变值时，使用Arc<Mutex<T>>或Arc<RwLock<T>>

2. 避免循环引用

使用Rc<T>和RefCell<T>时，要注意避免循环引用，否则会导致内存泄漏。

use std::rc::Rc;
use std::cell::RefCell;

#[derive(Debug)]
struct Node {
    value: i32,
    parent: Option<Rc<RefCell<Node>>>,
    children: RefCell<Vec<Rc<RefCell<Node>>>>,
}

fn main() {
    let parent = Rc::new(RefCell::new(Node {
        value: 1,
        parent: None,
        children: RefCell::new(vec![]),
    }));
    
    let child = Rc::new(RefCell::new(Node {
        value: 2,
        parent: Some(Rc::clone(&parent)),
        children: RefCell::new(vec![]),
    }));
    
    parent.borrow_mut().children.borrow_mut().push(Rc::clone(&child));
    
    println!("父节点: {:?}", parent);
    println!("子节点: {:?}", child);
    
    // 这里存在循环引用：parent -> child -> parent
    // 当它们离开作用域时，引用计数不会变为0，导致内存泄漏
}