# Ownership và Borrowing trong Rust: Hướng Dẫn Toàn Diện

> Làm chủ hệ thống ownership và borrowing của Rust. Quy tắc sở hữu, tham chiếu, lifetime và các mẫu quản lý bộ nhớ nâng cao.

- Published: 2026-02-20
- Updated: 2026-04-29
- Author: SharpSkill
- Tags: rust, ownership, borrowing, memory management, systems programming
- Reading time: 18 min

---

Hệ thống ownership chính là điều phân biệt Rust với mọi ngôn ngữ lập trình khác. Cách tiếp cận độc đáo này đảm bảo an toàn bộ nhớ mà không cần garbage collector, phát hiện lỗi tại thời điểm biên dịch thay vì runtime. Hướng dẫn chi tiết này khám phá các cơ chế ownership và borrowing, từ nền tảng cơ bản đến các mẫu sản xuất nâng cao.

> **Triết Lý của Rust**
>
> Trình biên dịch Rust hoạt động như một trợ lý lập trình khắt khe: mỗi lỗi ownership bị chặn tại thời điểm biên dịch đại diện cho một lỗi tiềm tàng được ngăn chặn trong production.

## Ba Quy Tắc Cơ Bản của Ownership

Hệ thống ownership dựa trên ba quy tắc đơn giản nhưng nghiêm ngặt. Khi đã thấm nhuần, mô hình tư duy của Rust trở nên tự nhiên và có thể dự đoán được.

```rust
// ownership_rules.rs
// Demonstration of the three fundamental rules

fn main() {
    // Rule 1: Each value has exactly ONE owner
    let s1 = String::from("hello");  // s1 is the sole owner

    // Rule 2: There can only be one owner at a time
    let s2 = s1;  // Ownership transferred (moved) from s1 to s2
    // println!("{}", s1);  // Compile ERROR: s1 no longer exists
    println!("s2 = {}", s2);  // Only s2 is valid now

    // Rule 3: When the owner goes out of scope, the value is dropped
    {
        let s3 = String::from("temporary");
        println!("s3 inside block = {}", s3);
    }  // s3 is automatically freed here (drop is called)
    // println!("{}", s3);  // ERROR: s3 no longer exists
}
```

Ba quy tắc này loại bỏ toàn bộ các loại lỗi: use-after-free, double-free và rò rỉ bộ nhớ. Trình biên dịch xác minh tĩnh rằng các quy tắc này được tuân thủ.

## Move vs Copy: Hiểu Ngữ Nghĩa Chuyển Giao

Hành vi của phép gán phụ thuộc vào kiểu dữ liệu. Các kiểu triển khai trait Copy được sao chép, trong khi các kiểu khác được chuyển giao qua move.

```rust
// move_vs_copy.rs
// Distinction between Copy types and Move types

fn main() {
    // Copy types: values stored on the stack, known size
    let x: i32 = 42;
    let y = x;  // x is COPIED, not moved
    println!("x = {}, y = {}", x, y);  // Both are valid

    // Other Copy types: f64, bool, char, tuples of Copy types
    let point = (3.0, 4.0);
    let point_copy = point;  // Tuple copy
    println!("Original: {:?}, Copy: {:?}", point, point_copy);

    // Move types: values on the heap, dynamic size
    let s1 = String::from("owned");
    let s2 = s1;  // s1 is MOVED to s2
    // println!("{}", s1);  // ERROR: value moved
    println!("s2 = {}", s2);

    // Vec, HashMap, Box are also Move types
    let vec1 = vec![1, 2, 3];
    let vec2 = vec1;  // Move, not copy
    // println!("{:?}", vec1);  // ERROR
    println!("vec2 = {:?}", vec2);
}

// Explicit clone to duplicate Move types
fn explicit_clone() {
    let original = String::from("important data");
    let clone = original.clone();  // Explicit duplication (memory cost)

    println!("Original: {}", original);  // Still valid
    println!("Clone: {}", clone);  // Independent copy
}
```

Sự phân biệt Move/Copy là cơ bản: nó quyết định liệu phép gán có chuyển giao quyền sở hữu hay tạo ra một bản sao độc lập.

> **Khi Nào Sử Dụng Clone**
>
> Gọi `.clone()` cần phải có chủ ý. Mã đầy clone có thể chỉ ra vấn đề về thiết kế. Borrowing thường là giải pháp tốt hơn.

## Borrowing: Tham Chiếu Bất Biến và Khả Biến

Borrowing cho phép truy cập một giá trị mà không cần lấy quyền sở hữu của nó. Cơ chế này khiến mã Rust vừa an toàn vừa hiệu năng.

```rust
// borrowing_basics.rs
// Immutable and mutable references

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

    // Immutable reference: read-only, multiple allowed
    let len = calculate_length(&s);  // Immutable borrow
    println!("'{}' has {} characters", s, len);  // s still valid

    // Multiple simultaneous immutable references: OK
    let r1 = &s;
    let r2 = &s;
    let r3 = &s;
    println!("r1={}, r2={}, r3={}", r1, r2, r3);
}

fn calculate_length(s: &String) -> usize {
    // s is a reference, not the owner
    s.len()
}  // s goes out of scope but doesn't drop anything (not owner)

// Mutable references: modification allowed
fn mutable_borrowing() {
    let mut s = String::from("hello");

    change(&mut s);  // Mutable borrow
    println!("After modification: {}", s);
}

fn change(s: &mut String) {
    s.push_str(", world!");  // Modification via mutable reference
}
```

Quy tắc vàng của borrowing: hoặc nhiều tham chiếu bất biến HOẶC một tham chiếu khả biến duy nhất, không bao giờ cả hai đồng thời.

## Quy Tắc của Borrow Checker

Borrow checker là thành phần của trình biên dịch xác minh các quy tắc borrowing. Hiểu được các lỗi của nó cho phép giải quyết vấn đề nhanh chóng.

```rust
// borrow_checker_rules.rs
// Strict borrow checker rules

fn main() {
    // RULE 1: No mutable reference with immutable references
    let mut s = String::from("hello");

    let r1 = &s;      // Immutable reference: OK
    let r2 = &s;      // Another immutable reference: OK
    // let r3 = &mut s;  // ERROR: cannot borrow as mutable
    println!("{} and {}", r1, r2);

    // AFTER using r1 and r2, they are "dead"
    let r3 = &mut s;  // Now OK: r1 and r2 no longer used
    r3.push_str(" world");
    println!("{}", r3);

    // RULE 2: Only one mutable reference at a time
    let mut data = String::from("exclusive");
    let ref1 = &mut data;
    // let ref2 = &mut data;  // ERROR: already borrowed mutably
    ref1.push_str("!");
    println!("{}", ref1);
}

// RULE 3: References cannot outlive the data
fn dangling_reference_prevented() {
    let reference;
    {
        let s = String::from("short-lived");
        // reference = &s;  // ERROR: s doesn't live long enough
    }
    // s is dropped here, reference would be invalid

    // Solution: move the value out of the scope
    let owned_outside;
    {
        let s = String::from("moved out");
        owned_outside = s;  // Move, not reference
    }
    println!("{}", owned_outside);  // OK: owned_outside is the owner
}
```

Borrow checker sử dụng Non-Lexical Lifetimes (NLL): một tham chiếu được coi là hoạt động chỉ đến lần sử dụng cuối cùng, không phải đến cuối scope.

## Lifetime: Chú Thích Thời Gian Sống của Tham Chiếu

Lifetime là các chú thích giúp trình biên dịch xác minh rằng các tham chiếu vẫn hợp lệ. Phần lớn thời gian, chúng được suy luận tự động.

```rust
// lifetimes_explained.rs
// Explicit lifetime annotations

// Without annotation: compiler infers lifetimes
fn first_word(s: &str) -> &str {
    match s.find(' ') {
        Some(i) => &s[..i],
        None => s,
    }
}

// With explicit annotation: same function
fn first_word_explicit<'a>(s: &'a str) -> &'a str {
    // 'a means: returned reference lives as long as the input
    match s.find(' ') {
        Some(i) => &s[..i],
        None => s,
    }
}

// When annotations are necessary: multiple references
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    // Compiler cannot guess which reference is returned
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let string1 = String::from("long string");
    let result;
    {
        let string2 = String::from("xyz");
        result = longest(&string1, &string2);
        println!("Longest: {}", result);  // OK here
    }
    // println!("{}", result);  // ERROR if uncommented: string2 dropped
}
```

Lifetime không thay đổi thời gian dữ liệu tồn tại; chúng mô tả mối quan hệ giữa thời gian sống của các tham chiếu khác nhau.

## Lifetime trong Struct

Khi một struct chứa các tham chiếu, lifetime phải được chú thích để đảm bảo struct không sống lâu hơn dữ liệu được tham chiếu.

```rust
// struct_lifetimes.rs
// Structs containing references

// Struct with reference: lifetime required
struct ImportantExcerpt<'a> {
    part: &'a str,  // This reference must live at least as long as the struct
}

impl<'a> ImportantExcerpt<'a> {
    // Method returning a reference with the same lifetime
    fn level(&self) -> i32 {
        3
    }

    // Elision rule: &self implies the output lifetime
    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention: {}", announcement);
        self.part  // Returns with 'a lifetime from self
    }
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().unwrap();

    let excerpt = ImportantExcerpt {
        part: first_sentence,  // OK: novel outlives excerpt
    };

    println!("Excerpt: {}", excerpt.part);
    println!("Level: {}", excerpt.level());
}

// Static lifetime: reference valid for the entire program duration
fn static_lifetime_example() {
    let s: &'static str = "This string is in the binary";
    // String literals always have 'static lifetime
    println!("{}", s);
}
```

Các quy tắc elision lifetime thường cho phép bỏ qua chú thích trong các trường hợp phổ biến, làm cho mã dễ đọc hơn.

## Mẫu Nâng Cao: Tính Khả Biến Bên Trong

Đôi khi tính khả biến phải được xác minh tại runtime thay vì thời điểm biên dịch. Rust cung cấp các kiểu cho mẫu này: RefCell và Cell.

```rust
// interior_mutability.rs
// Interior mutability with RefCell and Cell

use std::cell::{Cell, RefCell};

// Cell: for Copy types, replaces the entire value
struct Counter {
    count: Cell<u32>,  // Mutable despite &self
}

impl Counter {
    fn new() -> Counter {
        Counter { count: Cell::new(0) }
    }

    fn increment(&self) {
        // Modification via immutable reference!
        self.count.set(self.count.get() + 1);
    }

    fn get(&self) -> u32 {
        self.count.get()
    }
}

// RefCell: for non-Copy types, checks at runtime
struct CachedValue {
    value: RefCell<Option<String>>,
}

impl CachedValue {
    fn new() -> CachedValue {
        CachedValue { value: RefCell::new(None) }
    }

    fn get_or_compute(&self, compute: impl FnOnce() -> String) -> String {
        // borrow() for reading, borrow_mut() for writing
        if self.value.borrow().is_none() {
            *self.value.borrow_mut() = Some(compute());
        }
        self.value.borrow().as_ref().unwrap().clone()
    }
}

fn main() {
    let counter = Counter::new();
    counter.increment();
    counter.increment();
    println!("Counter: {}", counter.get());  // 2

    let cache = CachedValue::new();
    let result = cache.get_or_compute(|| {
        println!("Expensive computation...");
        String::from("result")
    });
    println!("Value: {}", result);

    // Second call: no recomputation
    let result2 = cache.get_or_compute(|| String::from("never executed"));
    println!("Cache hit: {}", result2);
}
```

RefCell và Cell chuyển việc kiểm tra borrowing sang runtime. Vi phạm quy tắc gây ra panic thay vì lỗi biên dịch.

> **Cẩn Thận với Panic**
>
> `RefCell::borrow_mut()` gây panic nếu giá trị đã được mượn. Nên sử dụng `try_borrow_mut()` để xử lý lỗi rõ ràng.

## Smart Pointer và Ownership

Các smart pointer như Box, Rc và Arc cung cấp các chiến lược ownership khác nhau cho các trường hợp sử dụng cụ thể.

```rust
// smart_pointers.rs
// Box, Rc, and Arc for different ownership patterns

use std::rc::Rc;
use std::sync::Arc;
use std::thread;

// Box: single owner, data on the heap
fn box_example() {
    let boxed = Box::new(vec![1, 2, 3, 4, 5]);
    println!("Boxed vec: {:?}", boxed);
    // Useful for: recursive types, large objects, trait objects
}

// Rc: reference counting, multiple owners (single-thread)
fn rc_example() {
    let data = Rc::new(String::from("shared data"));

    let clone1 = Rc::clone(&data);  // Increments the counter
    let clone2 = Rc::clone(&data);

    println!("Count: {}", Rc::strong_count(&data));  // 3
    println!("All share: {}, {}, {}", data, clone1, clone2);
}  // Freed when counter reaches 0

// Arc: thread-safe Rc (Atomic Reference Counting)
fn arc_example() {
    let data = Arc::new(vec![1, 2, 3]);

    let handles: Vec<_> = (0..3).map(|i| {
        let data_clone = Arc::clone(&data);
        thread::spawn(move || {
            println!("Thread {}: {:?}", i, data_clone);
        })
    }).collect();

    for handle in handles {
        handle.join().unwrap();
    }
}

fn main() {
    box_example();
    rc_example();
    arc_example();
}
```

Việc lựa chọn smart pointer phụ thuộc vào mẫu ownership: duy nhất (Box), chia sẻ đơn luồng (Rc) hoặc chia sẻ đa luồng (Arc).

## Mẫu Ownership Thực Tế

Dưới đây là các mẫu phổ biến để cấu trúc mã xung quanh hệ thống ownership.

```rust
// ownership_patterns.rs
// Practical patterns for ownership management

// Pattern 1: Builder pattern with chained ownership
struct RequestBuilder {
    url: String,
    headers: Vec<(String, String)>,
    timeout: Option<u64>,
}

impl RequestBuilder {
    fn new(url: &str) -> Self {
        RequestBuilder {
            url: url.to_string(),
            headers: Vec::new(),
            timeout: None,
        }
    }

    // Consumes self and returns the new self
    fn header(mut self, key: &str, value: &str) -> Self {
        self.headers.push((key.to_string(), value.to_string()));
        self  // Returns ownership
    }

    fn timeout(mut self, seconds: u64) -> Self {
        self.timeout = Some(seconds);
        self
    }

    fn build(self) -> Request {
        Request {
            url: self.url,
            headers: self.headers,
            timeout: self.timeout.unwrap_or(30),
        }
    }
}

struct Request {
    url: String,
    headers: Vec<(String, String)>,
    timeout: u64,
}

// Pattern 2: Cow (Copy-on-Write) to avoid allocations
use std::borrow::Cow;

fn process_text(input: &str) -> Cow<str> {
    if input.contains("REPLACE") {
        // Allocation only if modification needed
        Cow::Owned(input.replace("REPLACE", "NEW"))
    } else {
        // No allocation, returns a reference
        Cow::Borrowed(input)
    }
}

// Pattern 3: Take to extract from an Option
fn extract_value(data: &mut Option<String>) -> String {
    data.take().unwrap_or_else(|| String::from("default"))
    // take() replaces with None and returns ownership of the value
}

fn main() {
    // Builder pattern
    let request = RequestBuilder::new("https://api.example.com")
        .header("Authorization", "Bearer token")
        .header("Content-Type", "application/json")
        .timeout(60)
        .build();

    println!("URL: {}, Timeout: {}s", request.url, request.timeout);

    // Cow pattern
    let text1 = process_text("hello world");  // No allocation
    let text2 = process_text("hello REPLACE");  // Allocation
    println!("{} | {}", text1, text2);

    // Take pattern
    let mut optional = Some(String::from("extracted"));
    let value = extract_value(&mut optional);
    println!("Value: {}, Option: {:?}", value, optional);  // None
}
```

Những mẫu này tận dụng hệ thống ownership để tạo ra các API tiện dụng và hiệu năng.

## Kết Luận

Hệ thống ownership và borrowing của Rust đại diện cho sự thay đổi mô hình trong quản lý bộ nhớ. Khi đã thành thạo, nó trở thành một đồng minh mạnh mẽ để viết mã vừa hiệu năng vừa an toàn.

**Những điểm chính cần ghi nhớ:**

✅ Ba quy tắc ownership: chủ sở hữu duy nhất, chuyển giao quyền sở hữu, drop tự động

✅ Borrowing: nhiều tham chiếu bất biến HOẶC một tham chiếu khả biến độc quyền

✅ Lifetime: chú thích mối quan hệ giữa thời gian sống của các tham chiếu

✅ Tính khả biến bên trong: RefCell và Cell cho tính khả biến được xác minh tại runtime

✅ Smart pointer: Box (duy nhất), Rc (chia sẻ), Arc (thread-safe)

✅ Mẫu thực tế: Builder, Cow, Take cho các API mang tính idiomatic

Borrow checker có thể có vẻ nghiêm ngặt lúc đầu, nhưng mỗi lỗi nó báo cáo đại diện cho một bug tiềm tàng được tránh. Với thực hành, suy nghĩ theo ngôn ngữ ownership trở nên tự nhiên và cải thiện chất lượng mã trên mọi ngôn ngữ.

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/vi/blog/rust/ownership-borrowing-rust-complete-guide