Quyền Sở Hữu (Ownership): Bí Mật Lõi Của An Toàn Bộ Nhớ Trong Rust

Nếu không hiểu rõ Ownership, bạn sẽ liên tục gặp phải những lỗi biên dịch khó hiểu từ trình biên dịch (borrow checker). Nhưng một khi đã nắm bắt được triết lý của nó, bạn sẽ thấy đây là cơ chế tuyệt vời giúp quản lý bộ nhớ cực kỳ tối ưu mà hoàn toàn không cần đến Garbage Collector. Cùng mổ xẻ chi tiết ngay dưới đây.

🧠 1. Bài toán quản lý bộ nhớ: Tại sao Ownership ra đời?

Trong thế giới lập trình hệ thống, việc cấp phát và giải phóng bộ nhớ luôn là một cơn ác mộng:

C / C++: Lập trình viên phải tự tay gọi malloc/free hoặc new/delete. Quên giải phóng thì dính Memory Leak (rò rỉ bộ nhớ); giải phóng xong mà vẫn truy cập thì dính Use-After-Free (lỗi con trỏ hoang) dẫn đến sập chương trình hoặc lỗ hổng bảo mật.
Java, Python, C#: Sử dụng Garbage Collector (GC) để tự động quét và dọn rác ngầm. An toàn nhưng đổi lại là tốn tài nguyên RAM và gây ra những khoảng khựng trễ (latency spikes) không mong muốn.

Rust chọn một hướng đi hoàn toàn khác. Nó quản lý bộ nhớ thông qua một bộ quy tắc nghiêm ngặt tại thời điểm biên dịch (compile-time) gọi là Ownership. Trình biên dịch sẽ kiểm tra quyền sở hữu của mọi ô nhớ từ trước khi chương trình kịp chạy.

📦 2. Stack và Heap: Nền tảng lưu trữ dữ liệu

Trước khi đi vào quy tắc, bạn cần phân biệt rõ hai vùng nhớ cơ bản:

Stack (Ngăn xếp): Lưu trữ dữ liệu có kích thước cố định, biết trước tại thời điểm biên dịch (ví dụ: các số nguyên i32, kiểu bool, char). Dữ liệu trên Stack được sắp xếp theo kiểu LIFO (Last In, First Out) với tốc độ truy xuất cực nhanh.
Heap (Vùng nhớ động): Lưu trữ dữ liệu có kích thước thay đổi được hoặc chưa biết trước khi biên dịch (ví dụ: chuỗi ký tự dài String, vector, dynamic data). Khi bạn đẩy dữ liệu lên Heap, hệ điều hành sẽ tìm một khoảng trống đủ lớn, đánh dấu nó là đang dùng và trả về một con trỏ (pointer) trỏ tới vị trí đó. Con trỏ này có kích thước cố định nên nằm trên Stack, còn dữ liệu thực tế nằm trên Heap.

👑 3. Ba Quy Tắc Vàng Của Ownership

Mọi cơ chế quản lý bộ nhớ của Rust đều xoay quanh ba quy tắc cốt lõi sau:

Mỗi giá trị trong Rust đều có một chủ sở hữu (owner) — đó chính là biến gán cho nó.
Tại một thời điểm, chỉ duy nhất một owner được tồn tại cho một giá trị.
Khi owner vượt ra ngoài phạm vi hiệu lực của nó (out of scope), giá trị đó sẽ bị hủy hoàn toàn (dropped) và bộ nhớ được thu hồi ngay lập tức.

fn main() {
    {
        let s = String::from("hello"); // s bắt đầu có hiệu lực tại đây (vào scope)
        println!("{s}");
    } // Kết thúc block scope này, s ra ngoài phạm vi -> Rust tự động gọi hàm drop() để giải phóng bộ nhớ trên Heap của s.
    
    // println!("{s}"); // ❌ LỖI BIÊN DỊCH! s không còn tồn tại ở đây nữa.
}

🔄 4. Hiện tượng Move (Di chuyển quyền sở hữu)

Khi bạn gán một biến lưu trữ dữ liệu trên Heap cho một biến khác, điều gì sẽ xảy ra?

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // Quyền sở hữu đã bị "Move" sang s2!

    // println!("{s1}"); // ❌ LỖI BIÊN DỊCH! s1 không còn sở hữu giá trị nữa.
    println!("{s2}"); // ✅ Hoàn toàn hợp lệ.
}

Giải mã bản chất: Dữ liệu String bao gồm một con trỏ, dung lượng (capacity) và độ dài (length) nằm trên Stack, còn nội dung chữ "hello" nằm trên Heap. Khi viết let s2 = s1;, Rust sao chép phần dữ liệu trên Stack sang s2. Tuy nhiên, để tránh thảm họa "giải phóng bộ nhớ hai lần" (double free error) khi cả hai biến cùng ra khỏi scope, Rust đánh dấu s1 là không còn hợp lệ. Hiện tượng này gọi là Move.

(Lưu ý: Đối với các kiểu dữ liệu có kích thước cố định nằm hoàn toàn trên Stack như số nguyên i32, Rust thực hiện sao chép nông/sâu tự động gọi là Copy, nghĩa là biến cũ vẫn dùng bình thường sau khi gán).

📋 5. Sao chép thực sự với .clone()

Nếu bạn thực sự muốn nhân bản toàn bộ dữ liệu nằm trên Heap thay vì chuyển quyền sở hữu (Move), bạn phải chủ động gọi phương thức .clone():

fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone(); // Tạo một bản sao độc lập hoàn toàn trên Heap

    println!("s1 = {s1}, s2 = {s2}"); // ✅ Cả hai biến đều hoạt động bình thường!
}

📥 6. Ownership trong Hàm (Functions)

Việc truyền tham số vào hàm cũng tuân thủ chính xác quy tắc Ownership tương tự như phép gán biến:

fn main() {
    let s = String::from("hello");

    takes_ownership(s); // Biến s bị "Move" vào trong hàm, s bên ngoài main chính thức mất quyền sở hữu!

    // println!("{s}"); // ❌ LỖI BIÊN DỊCH! Không thể dùng lại s ở đây.

    let x = 5;
    makes_copy(x); // x là kiểu i32 (Copy trait), vẫn dùng ngon lành sau khi truyền vào hàm.
    println!("x vẫn dùng được: {x}");
}

fn takes_ownership(some_string: String) {
    println!("{some_string}");
} // some_string ra khỏi scope ở đây và bộ nhớ Heap bị giải phóng.

fn makes_copy(some_integer: i32) {
    println!("{some_integer}");
}

Thông qua cơ chế Ownership, Rust đảm bảo an toàn bộ nhớ tuyệt đối ngay tại thời điểm biên dịch mà không cần đến Garbage Collector.

Tuy nhiên, việc cứ phải "Move" liên tục dữ liệu vào hàm rồi lại trả ra bằng tuple sẽ rất rườm rà. Làm thế nào để chia sẻ dữ liệu mà không làm mất quyền sở hữu? Đó chính là nội dung của Bài 5: Borrowing và References (Mượn và Tham chiếu). Hẹn gặp lại bạn ở bài tiếp theo!