# Day 28: Explore shared-state concurrency with Mutex and RwLock.

On Day 28, let's delve into shared-state concurrency using Mutex (Mutual Exclusion) and RwLock (Read-Write Lock) in Rust. These synchronization primitives help manage access to shared data among multiple threads.

## **Shared-State Concurrency with Mutex and RwLock**

### **Mutex (Mutual Exclusion)**

Mutex provides exclusive access to shared data by allowing only one thread to acquire the lock at a time. It ensures that the data remains consistent while being accessed by multiple threads.

#### Example:

```rust
use std::sync::Mutex;
use std::thread;

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

    let handle = thread::spawn(move || {
        let mut num = data.lock().unwrap();
        *num += 1;
    });

    handle.join().expect("Thread panicked!");

    println!("Data: {:?}", data.lock().unwrap());
}
```

### **RwLock (Read-Write Lock)**

RwLock allows multiple threads to acquire read access simultaneously but enforces exclusive access for write operations. This enables multiple readers or a single writer at a time, ensuring data consistency.

#### Example:

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

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

    for _ in 0..5 {
        let data = Arc::clone(&data);
        let handle = thread::spawn(move || {
            let num = data.read().unwrap();
            println!("Read Data: {}", *num);
        });
        handles.push(handle);
    }

    let write_handle = thread::spawn(move || {
        let mut num = data.write().unwrap();
        *num = 42;
    });

    handles.into_iter().for_each(|h| h.join().expect("Thread panicked!"));
    write_handle.join().expect("Write thread panicked!");

    println!("Final Data: {:?}", *data.read().unwrap());
}
```

## **Conclusion**

Mutex and RwLock are crucial synchronization primitives in Rust for managing shared-state concurrency. While Mutex provides exclusive access for both reading and writing, RwLock allows multiple readers or a single writer, balancing concurrency and data consistency.

Understanding and effectively utilizing Mutex and RwLock helps ensure thread safety and prevent data races in multi-threaded applications. Keep exploring and practicing these synchronization primitives to build robust and efficient concurrent Rust programs!

Happy coding with Rust!

I hope this helps, you!!

**More such articles:**

[https://medium.com/techwasti](Link)

[https://www.youtube.com/@maheshwarligade](https://www.youtube.com/@maheshwarligade)

[https://www.techwasti.com/](Link)

\==========================\*\*=========================

**If this article adds any value to you then please clap and comment.**

**Let’s connect on** [**Stackoverflow**](http://stackoverflow.com/users/3187349/maheshwar-ligade)**,** [**LinkedIn**](https://in.linkedin.com/in/maheshwar-ligade-14447841)**, &** [**Twitter**](https://twitter.com/MaheshwarLigade)**.**