Rust 所有权系统：深入浅出指南

所有权是 Rust 最核心的特性，它使 Rust 能在无需垃圾回收的情况下保证内存安全。下面我将用直观的方式解释所有权系统：

所有权三大原则

每个值都有唯一的所有者
值在所有者离开作用域时被自动释放
同一时间只能有一个可变引用，或多个不可变引用

rust 复制代码

fn main() {
    // 所有权示例
    let s1 = String::from("hello"); // s1 成为所有者
    let s2 = s1; // 所有权转移给 s2
    
    // println!("{}", s1); // 错误！s1 不再拥有数据
    println!("{}", s2); // 正确
} // s2 离开作用域，内存自动释放

所有权转移（Move）

当变量赋值给另一个变量或作为函数参数传递时，所有权会发生转移：

rust 复制代码

fn take_ownership(s: String) {
    println!("函数内: {}", s);
} // s 离开作用域，内存释放

fn main() {
    let s = String::from("hello");
    take_ownership(s); // 所有权转移到函数
    
    // println!("{}", s); // 错误！s 不再有效
}

借用（Borrowing）

为了避免所有权转移，可以使用引用（借用）：

rust 复制代码

fn calculate_length(s: &String) -> usize {
    s.len()
} // 不释放内存，因为不拥有所有权

fn main() {
    let s = String::from("hello");
    let len = calculate_length(&s); // 借用 s
    println!("'{}' 的长度是 {}", s, len); // s 仍然有效
}

引用规则

不可变引用：可以有多个只读引用
可变引用：只能有一个可写引用
互斥规则：不能同时存在可变和不可变引用

rust 复制代码

fn main() {
    let mut s = String::from("hello");
    
    let r1 = &s; // 不可变引用 OK
    let r2 = &s; // 不可变引用 OK
    // let r3 = &mut s; // 错误！不能同时有不可变和可变引用
    
    println!("{}, {}", r1, r2);
    
    let r3 = &mut s; // 现在可以创建可变引用
    r3.push_str(", world");
}

生命周期（Lifetimes）

编译器使用生命周期确保引用始终有效：

rust 复制代码

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let s1 = String::from("abcd");
    let result;
    {
        let s2 = String::from("xyz");
        result = longest(s1.as_str(), s2.as_str());
        println!("最长的字符串是 {}", result);
    }
    // println!("{}", result); // 错误！s2 已离开作用域
}

所有权实践技巧

需要修改数据时使用可变引用：

rust 复制代码

fn add_prefix(s: &mut String) {
    s.insert_str(0, "前缀: ");
}

2. 需要返回数据所有权时直接返回值：

rust 复制代码

fn create_greeting(name: &str) -> String {
    format!("你好, {}!", name)
}

3. 需要多个返回值时使用元组：

rust 复制代码

fn split_at(s: String, mid: usize) -> (String, String) {
    let first = s[..mid].to_string();
    let second = s[mid..].to_string();
    (first, second)
}

所有权图解

rust 复制代码

+---------+      +---------------+
| 所有者  | ---> |   值（数据）   |
+---------+      +---------------+
     |
     | 转移所有权
     v
+---------+      +---------------+
| 新所有者 | ---> |   值（数据）   |
+---------+      +---------------+

常见问题解决

问题： 需要在多个地方使用同一个值
解决方案： 使用 Rc<T>（引用计数智能指针）

rust 复制代码

use std::rc::Rc;

fn main() {
    let s = Rc::new(String::from("共享数据"));
    let s1 = Rc::clone(&s);
    let s2 = Rc::clone(&s);
    
    println!("{}, {}, {}", s, s1, s2);
} // 当所有引用计数归零时，内存释放

问题： 需要在多个线程间共享数据
解决方案： 使用 Arc<T>（原子引用计数）

rust 复制代码

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

fn main() {
    let s = Arc::new(String::from("多线程共享"));
    let mut handles = vec![];
    
    for _ in 0..3 {
        let s_clone = Arc::clone(&s);
        handles.push(thread::spawn(move || {
            println!("{}", s_clone);
        }));
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
}

所有权优势

内存安全：避免悬垂指针、双重释放等问题
并发安全：编译时防止数据竞争
高效内存管理：无需运行时垃圾回收
明确资源管理：资源释放时机可预测