What does Rust have instead of a garbage collector?

In Rust, there is no traditional garbage collector (GC). Rust employs a memory management system called ownership to replace garbage collectors. The ownership system manages memory through a set of compile-time rules, rather than managing memory at runtime like traditional garbage collectors. This approach avoids data races, null pointer dereferences, and other issues at compile time while eliminating the performance overhead of runtime garbage collection.

Key Features

1. Ownership

   • Each value in Rust has a variable known as its owner.
   • Only one owner can exist at a time.
   • When the owner (variable) goes out of scope, the value is dropped.

2. Borrowing

   • Data can be borrowed via references, and borrowing is divided into immutable and mutable borrows.
   • Immutable borrows allow multiple references to coexist simultaneously, but they cannot modify the data.
   • Mutable borrows allow modifying the data, but only one mutable reference can be active at any time.

3. Lifetimes

   • Lifetimes are a static analysis tool that ensures all borrows are valid.
   • It helps the compiler understand when references remain valid and when they are no longer used.

Example

Suppose we have a struct Book and a function that uses Book, demonstrating how memory is managed without garbage collection.

rust
struct Book {
    title: String,
    pages: u32,
}

fn main() {
    let book = Book {
        title: String::from("Rust Programming"),
        pages: 250,
    };

    process_book(&book);

    // book is still available since we passed a reference
    println!("Book title: {}", book.title);
}

fn process_book(book: &Book) {
    println!("Processing book: {} with {} pages", book.title, book.pages);
    // We don't need to worry about when book is released, as its memory management is automatic
}

In this example, the ownership and borrowing rules ensure that book remains valid in main and is accessed via references in process_book, without causing ownership transfer or copying. This avoids issues like memory leaks or invalid memory access, and eliminates the runtime overhead of garbage collectors.

Overall, Rust provides a solution for effectively managing memory without garbage collectors through compile-time memory safety checks, which is particularly valuable in systems programming.