第 9 章：智能指针和内存管理

在这一章中，我们将深入探讨 Rust 中的智能指针和内存管理。这是 Rust 编程中的关键部分，理解和掌握这些内容将帮助你编写更高效、安全的系统级代码。

什么是智能指针

智能指针是一种数据结构，它不仅仅指向一个内存地址，还持有一些额外的信息和行为。智能指针在 Rust 中非常重要，因为它们帮助我们管理内存的生命周期，确保内存安全。

Box

Box<T> 是最简单的智能指针，它在堆上分配内存，用于存储 T 类型的值。Box<T> 适用于以下场景：

• 当你有大量数据在堆上分配时。
• 当你需要在编译时知道类型的大小。
• 当你想要转移所有权，但不想使用引用。

示例代码：

fn main() {
    let b = Box::new(5);
    println!("b = {}", b);
}

在这个例子中，Box::new(5) 在堆上分配了一个整数，并返回一个指向该整数的智能指针 b。

Rc 和 Arc

Rc<T> 和 Arc<T> 是两个用于引用计数的智能指针。它们允许多个所有者同时拥有同一个数据，使用引用计数来管理共享数据的生命周期。

Rc

Rc<T> 是单线程环境下的引用计数智能指针。如果你确定数据不会跨线程使用，可以选择 Rc<T>。

示例代码：

use std::rc::Rc;

fn main() {
    let a = Rc::new(5);
    let b = Rc::clone(&a);
    println!("a = {}, b = {}", a, b);
}

Rc::clone(&a) 会增加引用计数，而不会复制数据。这意味着 a 和 b 都指向相同的数据。

Arc

Arc<T> 是多线程环境下的引用计数智能指针。与 Rc<T> 不同，Arc<T> 是线程安全的。

示例代码：

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

fn main() {
    let a = Arc::new(5);
    let b = Arc::clone(&a);

    let handle = thread::spawn(move || {
        println!("b = {}", b);
    });

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

在这个例子中，Arc::clone(&a) 返回一个指向相同数据的引用计数智能指针 b，并且可以在新的线程中安全使用。

RefCell 和内部可变性

RefCell<T> 提供了一个运行时可变借用检查，它允许你在数据结构中修改不可变借用的数据。这是通过 Rust 的“内部可变性”模式实现的。

示例代码：

use std::cell::RefCell;

fn main() {
    let x = RefCell::new(42);
    *x.borrow_mut() += 1;
    println!("x = {}", x.borrow());
}

在这个例子中，RefCell::new(42) 创建了一个可变的整数，x.borrow_mut() 提供了对该整数的可变引用，并且可以在不可变引用的上下文中修改它。

Mutex 和同步原语

Mutex<T> 提供了一个互斥锁，用于保护共享数据的访问。它确保同一时刻只有一个线程可以访问数据，从而避免数据竞争。

示例代码：

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

fn main() {
    let data = Arc::new(Mutex::new(0));

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

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

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

在这个例子中，Arc::new(Mutex::new(0)) 创建了一个保护整数的互斥锁。每个线程通过锁访问和修改数据，确保线程安全。

内存管理总结

通过学习和使用 Box<T>、Rc<T>、Arc<T>、RefCell<T> 和 Mutex<T>，你可以在 Rust 中高效地管理内存和处理并发。智能指针和内存管理是 Rust 编程的核心内容之一，理解和掌握这些概念将帮助你编写更加健壮和高效的代码。