Shared Memory in Rust

Shared memory is a key concept in concurrent programming that allows multiple threads to access and modify the same data efficiently. Rust provides safe and efficient shared memory mechanisms through Arc, Mutex, and RwLock, ensuring memory safety while preventing data races.

---

01. Understanding Shared Memory in Rust

In traditional systems, shared memory is used for inter-thread or inter-process communication. However, in Rust, shared memory must be handled carefully due to ownership and borrowing rules. Rust provides smart pointers like Arc and synchronization primitives like Mutex to safely share memory across threads.

---

02. Using Arc for Shared Ownership

The Arc (Atomic Reference Counting) type allows multiple threads to share ownership of immutable data. It keeps track of the number of references to an object and ensures it is deallocated when no references remain.

use std::sync::Arc;
use std::thread;

fn main() {
    let shared_data = Arc::new(vec![1, 2, 3, 4, 5]);

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

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

Here, multiple threads share a reference to the same vector using Arc::clone, ensuring safe concurrent access.

---

03. Synchronizing Access with Mutex

For modifying shared data, Rust provides Mutex (Mutual Exclusion), which ensures that only one thread can access the data at a time.

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

fn main() {
    let counter = Arc::new(Mutex::new(0));

    let handles: Vec<_> = (0..5).map(|_| {
        let counter_clone = Arc::clone(&counter);
        thread::spawn(move || {
            let mut num = counter_clone.lock().unwrap();
            *num += 1;
        })
    }).collect();

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

    println!("Final count: {}", *counter.lock().unwrap());
}

Using Mutex, threads safely modify the shared counter without data races.

---

04. Using RwLock for Read-Write Access

Unlike Mutex, which allows only one thread to access data at a time, RwLock (Read-Write Lock) permits multiple readers or a single writer.

use std::sync::{Arc, RwLock};
use std::thread;

fn main() {
    let data = Arc::new(RwLock::new(5));

    let readers: Vec<_> = (0..3).map(|_| {
        let data_clone = Arc::clone(&data);
        thread::spawn(move || {
            let read_access = data_clone.read().unwrap();
            println!("Read: {}", *read_access);
        })
    }).collect();

    let writer = {
        let data_clone = Arc::clone(&data);
        thread::spawn(move || {
            let mut write_access = data_clone.write().unwrap();
            *write_access += 10;
            println!("Updated value: {}", *write_access);
        })
    };

    for reader in readers {
        reader.join().unwrap();
    }
    writer.join().unwrap();
}

RwLock ensures efficient concurrency by allowing multiple reads but exclusive writes.

---

05. Combining Arc and Mutex for Shared State

To allow safe concurrent modification of shared state, Arc and Mutex are often used together.

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

fn main() {
    let shared_state = Arc::new(Mutex::new(vec![]));

    let handles: Vec<_> = (0..5).map(|i| {
        let shared_clone = Arc::clone(&shared_state);
        thread::spawn(move || {
            let mut data = shared_clone.lock().unwrap();
            data.push(i);
        })
    }).collect();

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

    println!("Final shared data: {:?}", *shared_state.lock().unwrap());
}

This pattern allows multiple threads to safely update a shared vector.

---

06. Performance Considerations

• Use Arc for sharing immutable data to avoid unnecessary locks.
• Use Mutex for exclusive access but be mindful of deadlocks.
• Use RwLock when reads are frequent and writes are infrequent.
• Avoid excessive locking in performance-critical applications.

---

Conclusion

Rust's ownership model ensures that shared memory access remains safe and efficient. Using Arc for shared ownership, Mutex for synchronization, and RwLock for read-heavy scenarios allows developers to build robust concurrent applications.