Rust 语言特性深度解析

Rust 通过 所有权（Ownership）、生命周期（Lifetime）、借用检查器（Borrow Checker） 和 模式匹配（Pattern Matching） 等机制，在无 GC 情况下实现内存安全和高性能。本篇全面解析其核心机制与背后哲学。

什么是无GC

无 GC 情况”指的是：

没有垃圾回收器（Garbage Collector, GC）的前提下也就是说，Rust 不依赖 GC 来自动回收内存。
不是没有内存管理，而是采用另一套机制：所有权 + 生命周期 + 编译器检查。

语言	内存回收方式	说明
Java / Go / JS	GC 自动回收	程序运行时有一个垃圾回收器，定期扫描内存找出不再使用的对象并释放
C / C++	无 GC，手动释放	malloc/free 或 new/delete，开发者错误很容易出现
Rust	无 GC，自动管理	借助所有权系统 + 编译器静态分析 自动、无运行时开销地释放

1. 所有权系统（Ownership System）

Rust 的所有权系统是其内存安全机制的根基。

所有权三大规则

1. 每个值有且只有一个绑定的所有者

2. 值在赋值或传参时默认 Move 所有权

3. 所有者离开作用域时，值自动 drop

Copy 类型（特殊例外）

若类型实现 Copy trait，则赋值不会 Move：

• i32, f64, bool, char

• 固定大小数组 [T; N]

• Copy 是浅复制，开销极低

let x = 5;
let y = x; // Copy
println!("{}, {}", x, y);

 多所有权？用 Rc / Arc

Rust 默认独占所有权
但需要共享时：Rc<T>（单线程），Arc<T>（多线程）

use std::rc::Rc;
let a = Rc::new(10);
let b = Rc::clone(&a);
println!("count = {}", Rc::strong_count(&a));

2. 借用（Borrowing）

借用规则

1. 同一时间要么多个不可变引用

2. 要么一个可变引用

3. 引用必须有效

不可变借用

fn len(s: &String) -> usize { s.len() }

let s = String::from("rust");
println!("{}", len(&s));

可变借用

fn change(s: &mut String) { s.push_str(" lang") }

let mut s = String::from("rust");
change(&mut s);
println!("{}", s);

借用冲突检测（Borrow Checker）

let mut s = String::from("hello");

let r1 = &s;
let r2 = &s;
// let r3 = &mut s; 
println!("{}, {}", r1, r2);

let r3 = &mut s; //  r1,r2 已过使用点
println!("{}", r3);

 3. 生命周期（Lifetime）

生命周期 = 引用的有效作用域标记
编译器静态检查，确保无悬垂引用

基本语法

&'a T
&'a mut T

函数中的生命周期

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

'a 表示返回值生命周期 ≤ x 与 y 的公共生命周期

生命周期省略规则（自动推断 3 条）

1. 每个参数都有自己的生命周期参数

2. 若只有一个输入生命周期 → 推给输出

3. 若方法有 &self → 输出生命周期 = self

fn first(s: &str) -> &str { &s[..1] }  // 自动推断

4. 零成本抽象（Zero-cost Abstractions）

写高级表达力代码 → 编译成 C 级性能

例：链式 iterator 不开销额外 runtime

let sum: i32 = [1,2,3]
    .iter()
    .map(|x| x*2)
    .filter(|x| *x > 2)
    .sum();

编译器会优化为纯循环。

5. 并发安全：Send / Sync

trait	意义
Send	可安全在多线程间移动所有权
Sync	可安全从多线程共享引用

Rust 编译期保证无 data race

use std::thread;

let h = thread::spawn(|| println!("Hello thread"));
h.join().unwrap();

共享 & 可变 = Arc<Mutex<T>>：

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

let n = Arc::new(Mutex::new(0));
let mut handles = vec![];

for _ in 0..5 {
    let n = Arc::clone(&n);
    handles.push(thread::spawn(move || {
        *n.lock().unwrap() += 1;
    }));
}

for h in handles { h.join().unwrap(); }
println!("{}", *n.lock().unwrap());

6. 模式匹配（Pattern Matching）

match 必须穷尽所有情况

enum Coin { Penny, Nickel, Quarter(u8) }

match coin {
    Coin::Penny => 1,
    Coin::Nickel => 5,
    Coin::Quarter(state) => { println!("state {}", state); 25 },
}

if let 简洁写法

if let Some(x) = value {
    println!("{}", x);
}

while let

while let Some(x) = stack.pop() {
    println!("{}", x);
}

@ 绑定

match id {
    id @ 3..=7 => println!("range {}", id),
    _ => {}
}

7. 综合示例：生命周期 + 借用 + 类型系统

struct Wrapper<'a> {
    data: &'a str,
}

impl<'a> Wrapper<'a> {
    fn get(&self) -> &str { self.data }
}

违反生命周期：

let w;
{
    let s = String::from("hi");
    w = Wrapper { data: &s }; //  s 会提前 drop
}

特性	作用
所有权	保证内存安全，无 GC
借用/引用	编译期静态借用检查
生命周期	确保引用不悬空
Send / Sync	编译期线程安全
模式匹配	功能强大、穷尽性
零开销抽象	高层表达 + C 级性能