Shared State | Concurrency

Introduction to Shared State

In concurrent programming, shared state refers to data that can be accessed and modified by multiple threads. In Rust, the concept of shared state is crucial because it helps manage data safely across threads, preventing data races and ensuring memory safety.

Why Shared State Matters

When multiple threads attempt to read and write to the same variable without proper synchronization, it can lead to unpredictable behavior known as a data race. Rust's type system and ownership model help mitigate these issues by enforcing rules at compile time.

Using Mutex for Shared State

A Mutex (Mutual Exclusion) is a synchronization primitive that allows only one thread to access a resource at a time. In Rust, you can use the `std::sync::Mutex` type to wrap your shared data.

Example: Basic Mutex Usage

Here's a simple example demonstrating how to use a Mutex in Rust:

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

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

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

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

Output: Result: 10

Using RwLock for Shared State

An RwLock (Read-Write Lock) allows multiple readers or one writer at a time. This is useful when you have a scenario where reads are more frequent than writes.

Example: Basic RwLock Usage

Here's an example of using an RwLock in Rust:

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

fn main() {
    let data = Arc::new(RwLock::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let data = Arc::clone(&data);
        let handle = thread::spawn(move || {
            let mut num = data.write().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

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

    println!("Result: {}", *data.read().unwrap());
}