Rust 和 Go 的内存管理：一个像管家，一个像房东

🚪 场景还原：你租了一套房

• 房子 = 进程的内存空间
• 客厅 = 堆（heap）
• 抽屉 = 栈（stack）
• 你 = 程序

现在问题来了：谁来决定「一个茶杯能不能扔」？

🐹 Go：“你负责生活，我负责打扫”

Go 的内存哲学就一句：

✅ 人月神话终结者——让开发者专注业务，别想内存。

它怎么工作？

func main() {
    s := "Hello, World!"      // 栈上：值小，直接存
    p := &Person{Name: "小明"} // 堆上：结构体大，放堆里
    fmt.Println(s, p.Name)
    // 👉 此时 p 没人用了 → GC 会在某天（不确定哪天）回收它
}

✅ 优点：

• 写起来快如闪电 ⚡（:= 走天下）
• 不怕内存泄漏（长期小泄漏除外）
• 并发友好：goroutine 轻量，GC STW < 100μs（Go 1.14+）

⚠️ 痛点（真实故事）：

某次压测，QPS 从 10w 突降到 2w —— 日志里飘过一行：
gc 123 @12.456s 0.087s
“原来是你，GC 君。”
（STW 再短，高频场景也扛不住）

🦀 Rust：“在编译时就把垃圾扔了”

Rust 的内存哲学是：

✅ 零成本抽象 + 内存安全 = 运行时没有 GC，也没有悬垂指针

它靠三件套封神：

1️⃣ 所有权（Ownership）——“一物一主”

let s1 = String::from("hello");
let s2 = s1;  // ✅ s1 的“所有权”移交 s2
// println!("{}", s1); // ❌ 编译报错：value borrowed after move

💡 类比：
你把房卡交给朋友 → 你自己就不能开门了。
（除非……你复制一把——s2 = s1.clone()）

2️⃣ 借用（Borrowing）——“借可以，按时还”

fn main() {
    let s = String::from("hello");
    let len = calculate_length(&s); // 借“不可变引用”
    println!("len: {}", len);
    s.push_str(", world"); // ✅ s 仍是主人，能改
}

fn calculate_length(s: &String) -> usize {
    s.len() // 不拿走所有权，只“看一眼”
}

⚠️ 经典编译错误（新手必经之路）：

error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
 --> src/main.rs:5:5
  |
4 |     let len = calculate_length(&s);
  |                                -- immutable borrow occurs here
5 |     s.push_str(", world");
  |     ^^^^^^^^^^^^^^^^^^^^^^ mutable borrow occurs here

🐍 幽默翻译：
“尊敬的用户，您刚才借出了‘只读权限’，现在又想‘读写’——
这就像把书借给图书馆复印，自己却偷偷往里夹小抄。不行！”

3️⃣ 生命周期（Lifetimes）——“借多久，写清楚”

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

'a 就是“借条有效期”：返回的引用，不能比输入的任何一个活得长。

💡 类比：
你向室友借充电器：“用到今晚 10 点” —— 编译器会检查：
你 9:59 还了？✔️
你 10:01 还在用？❌ 编译失败！

📊 实战对比：谁更适合你？

🐹 Go 开发者日常：
“写个服务，跑起来——咦？怎么内存涨了？
哦，map 没清。加个 delete …… 还是涨？
啊！key 是指针！得手动 nil……”

🦀 Rust 开发者日常：
“写个服务，编译——
error: 12 处 borrow-checker 报错
改 2 小时……
编译通过！
运行：零 bug，零泄漏，零 GC pause
…… 值了。”

🎯 终极总结（人话版）

💬 一句话收尾：
Go 让你「快」起来，Rust 让你「敢」起来。
—— 快，是开发速度；敢，是线上零事故的底气。