ไม่มี Garbage Collector

ทุกภาษาที่คุณรู้จักมี garbage collector — Rust ไม่มี

Node.js, Python, Go, Java, C# — ทุกภาษา mainstream ที่คุณน่าจะเคยเขียนทำงานบน GC GC สแกน memory เป็นระยะ หา object ที่ไม่ถูกใช้แล้ว และคืน memory แบบนี้ปลอดภัยและสะดวก แต่มีต้นทุน:

Pause latency: GC stop-the-world pause สามารถ spike latency ได้อย่างคาดเดาไม่ได้
Throughput overhead: งาน GC แข่งกับโปรแกรมของคุณสำหรับ CPU time
Memory overhead: GC runtime เก็บ data structure พิเศษเพื่อ track live object
Non-determinism: คุณไม่สามารถทำนายได้ว่า object จะถูกคืนเมื่อไหร่

Rust ไม่มีสิ่งเหล่านี้เลย แต่ได้ memory safety มาจาก ownership model ล้วน ๆ ตัว Compiler พิสูจน์แบบ static ว่า memory ถูกจัดการถูกต้อง แล้ว generate โค้ดคืน allocation แต่ละก้อนในจุดที่ถูกต้องพอดี

🟦 RAII — Resource Acquisition Is Initialization

RAII คือ pattern ที่ Rust ใช้แทน GC เมื่อคุณสร้าง value ที่เป็น owner ของ resource (memory, file handle, mutex lock) resource นั้นจะถูก acquire เมื่อสร้าง และ release เมื่อ owner หลุด scope — อัตโนมัติ, แน่นอน, ไม่ต้องการ runtime

ไม่ใช่แค่ memory อะไรก็ตามเป็น resource ที่จัดการแบบนี้ได้:

String / Vec<T> — heap memory คืนเมื่อ drop
std::fs::File — file descriptor ปิดเมื่อ drop
MutexGuard<T> — mutex unlock เมื่อ drop
Database connection คืนสู่ pool เมื่อ drop

ใน TypeScript คุณใช้ try/finally หรือ proposal ล่าสุด (using) เพื่อให้ได้ cleanup ที่คล้ายกัน ใน Rust นี่คือ default สำหรับทุก value

”Drop” หน้าตาเป็นอย่างไร

คุณ implement Drop trait เพื่อ run cleanup logic แบบ custom เมื่อ value หลุด scope — เทียบเท่า destructor ของ Rust:

// TypeScript — ไม่มี deterministic cleanup โดย default
class Resource {
  constructor(private name: string) {
    console.log(`acquiring: ${name}`);
  }
  // ไม่มี guaranteed destructor ต้องใช้ try/finally หรือ 'using' (ES2023)
  release() {
    console.log(`releasing: ${this.name}`);
  }
}

function useResource() {
  const r = new Resource("file handle");
  console.log("using resource");
  r.release(); // ลืมเรียกได้ง่าย; ไม่ถูกเรียกถ้า exception
}
useResource();

struct Resource {
    name: String,
}

impl Resource {
    fn new(name: &str) -> Self {
        println!("acquiring: {}", name);
        Resource { name: name.to_string() }
    }
}

impl Drop for Resource {
    fn drop(&mut self) {
        println!("releasing: {}", self.name);
    }
}

fn main() {
    println!("start");
    {
        let _r = Resource::new("file handle");
        println!("using resource");
    } // _r ถูก drop ที่นี่ — drop() ถูกเรียกอัตโนมัติ
    println!("end — resource already released");
}

🟦 Ownership คือ memory management

ใน Rust ownership model คือ memory management model ไม่มีการแยกระหว่าง “ownership ทำงานอย่างไร” กับ “memory ถูกคืนอย่างไร” เพราะเป็นเรื่องเดียวกัน:

ทุก heap allocation เป็น owner โดยตัวแปรแค่ตัวเดียว
เมื่อตัวแปรนั้นหลุด scope allocation ก็ถูกคืน
Compiler บังคับกฎข้อ 1 และ 2 แบบ static — ไม่ต้องการ runtime

นี่คือเหตุผลที่ Rust รับประกัน memory safety (ไม่มี use-after-free, ไม่มี double-free, ไม่มี dangling pointer) ด้วย zero runtime overhead ทั้งระบบเป็นการพิสูจน์ตั้งแต่ compile time

GC language แลก runtime overhead กับความสะดวกของโปรแกรมเมอร์ Rust แลกกฎ ownership ที่ explicit กับ zero runtime overhead สำหรับ system software, embedded code, game engine, หรือ service ที่ sensitive เรื่อง latency model ของ Rust ชนะ

การ cleanup แบบ deterministic กับ non-deterministic

flowchart TD
  subgraph TS["TypeScript / Node.js"]
    a1["Object created"] --> a2["..."] --> a3["GC runs at some unknown time"] --> a4["memory freed"]
  end
  subgraph RS["Rust"]
    b1["Value created"] --> b2["owner goes out of scope"] --> b3["memory freed IMMEDIATELY"]
  end

Deterministic vs non-deterministic cleanup

ความแน่นอนนี้คือเหตุผลที่ Rust ถูกใช้สำหรับ OS kernel, game engine, WebAssembly runtime, และ database เมื่อ file handle หรือ network socket ต้องถูกปิดในจุดที่แน่นอน “GC จะจัดการในที่สุด” ไม่ใช่คำตอบที่ยอมรับได้

ลองเขียนเอง

Open in Rust Playground

struct Resource {
    name: String,
}

impl Resource {
    fn new(name: &str) -> Self {
        println!("acquiring: {}", name);
        Resource { name: name.to_string() }
    }
}

impl Drop for Resource {
    fn drop(&mut self) {
        println!("releasing: {}", self.name);
    }
}

fn main() {
    println!("start");
    {
        let _r = Resource::new("file handle");
        println!("using resource");
    }
    println!("end — resource already released");
}