How does ownership prevent memory leaks and data races?

Ownership is Rust's core memory management system, enforcing strict rules at compile time to ensure safety without a garbage collector. It prevents memory leaks and data races through a combination of ownership rules, move semantics, and borrowing.

Ownership in Rust

• Each value has a single owner (variable).
• When the owner goes out of scope, the value is dropped (Drop trait called).
• Ownership can be transferred (moved), making the original variable invalid.

Key Rules

Move Semantics

Assigning a heap-allocated value (e.g., String) to another variable transfers ownership, invalidating the original.

Example:

let s1 = String::from("hello");
let s2 = s1; // Ownership moved to s2
// println!("{}", s1); // Compile error: value borrowed after move

Copy vs. Move

• Types with known size (i32, bool) implement Copy and are cloned automatically.
• Heap-allocated types (String, Vec) do not implement Copy and are moved.

Function Calls

Passing a value to a function moves or copies it, following the same rules.

Example:

fn take_ownership(s: String) { /* ... */ }

let s = String::from("hello");
take_ownership(s); // Ownership moved into the function
// println!("{}", s); // Error: s is invalid

How Ownership Prevents Memory Leaks

• Automatic Cleanup: When the owner goes out of scope, Rust calls drop to free memory (no manual free() needed).
• No Double Frees: Since only one owner exists, the value is dropped exactly once.

How Ownership Prevents Data Races

• Borrowing Rules:
  • Immutable borrows (&T): Multiple allowed, but no mutable borrows can coexist.
  • Mutable borrows (&mut T): Only one allowed, and no other borrows can exist.
• Compile-Time Enforcement: The compiler rejects code that could lead to data races.

Example: Data Race Prevention:

let mut data = vec![1, 2, 3];

let r1 = &data; // Immutable borrow OK
let r2 = &data; // Another immutable borrow OK
// let r3 = &mut data; // ERROR: Cannot borrow as mutable while immutable borrows exist

println!("{:?}, {:?}", r1, r2);

Key Takeaways

Ownership ensures:

• No dangling pointers (via lifetimes).
• No memory leaks (via Drop).
• No data races (via borrowing rules).

Rust’s ownership model guarantees memory safety and concurrency safety at compile time, delivering performance and reliability.