What is a data race in Rust?

Data Race refers to a situation in concurrent programming where two or more threads access the same memory region without proper synchronization, and at least one thread is writing data. This can result in unpredictable program behavior and unexpected outcomes.

Rust's design features a unique system: the ownership system, combined with borrowing rules and lifetimes, collectively prevent data races. The Rust compiler enforces memory safety guarantees, ensuring all concurrent operations are safe.

How Rust Prevents Data Races

1. Ownership System: In Rust, every value has a variable known as its 'owner'. A value has exactly one owner, and when the owner goes out of scope, the value is destroyed. This rule ensures memory safety.

2. Borrowing Rules: Rust supports two forms of borrowing: immutable borrowing and mutable borrowing. Only one mutable borrow or any number of immutable borrows can exist at a time, but both cannot coexist simultaneously. This means, at any given moment, you can have multiple read accesses or only one write access, preventing data races.

3. Lifetimes: Rust uses lifetimes to ensure data remains valid while references are active. This helps prevent dangling pointers and other memory errors.

Example

Suppose we have a struct Account and want to access and modify its balance in a multi-threaded environment. In Rust, you cannot directly access and modify it unprotected across multiple threads, as shown below would cause a compilation error:

rust
use std::thread;

struct Account {
    balance: i32,
}

fn main() {
    let mut account = Account { balance: 100 };
    let account_ref = &mut account;

    let t1 = thread::spawn(move || {
        account_ref.balance += 50;
    });

    let t2 = thread::spawn(move || {
        account_ref.balance += 75;
    });

    t1.join().unwrap();
    t2.join().unwrap();

    println!("Account balance: {}", account.balance);
}

This code fails to compile because it attempts to mutably borrow account_ref in both threads concurrently. To correctly operate in a multi-threaded environment, you need to use synchronization mechanisms like Mutex:

rust
use std::sync::{Arc, Mutex};
use std::thread;

struct Account {
    balance: i32,
}

fn main() {
    let account = Arc::new(Mutex::new(Account { balance: 100 }));

    let t1 = {
        let account = Arc::clone(&account);
        thread::spawn(move || {
            let mut account = account.lock().unwrap();
            account.balance += 50;
        })
    };

    let t2 = {
        let account = Arc::clone(&account);
        thread::spawn(move || {
            let mut account = account.lock().unwrap();
            account.balance += 75;
        })
    };

    t1.join().unwrap();
    t2.join().unwrap();

    let account = account.lock().unwrap();
    println!("Account balance: {}", account.balance);
}

In this rewritten example, we use Mutex to ensure exclusive access when modifying balance. Arc is used to share ownership of Account across multiple threads, ensuring each thread can safely access the data. This guarantees memory safety and data correctness even in concurrent scenarios, thus avoiding data races.