Shared-State Concurrency

Mutex

• Mutual exclusion (mutex) is a mechanism to manage multiple threads accessing the same memory region. Only one thread can access a piece of data at a time.
• To access data in a mutex, a thread signals that wants to acquire the mutex lock. Lock is a data structure, part of the mutex, that keeps track of who’s accessing the data at any given time.
• Acquiring the lock must happen before using the data.
• A thread must unlock the data after using, so other threads can access it.
• This is an example of Mutex in action.

use std::sync::Mutex;

fn main() {
    let m = Mutex::new(5);

    {
        let mut num = m.lock().unwrap();
        *num = 6;
    }

    println!("m = {m:?}");
}

• After accessing the data, the thread gets a mutable reference to the value inside the lock.
• Type system ensures that a thread acquires the lock before using it, because m if of type Mutex<i32>
• In Rust, the Mutex type panics if someone else is holding the lock and a thread tries to get the hold of the lock.

Atomic Reference Counting

• [[Rust book - Rc]] is not enough to share mutex references along threads, since it doesn’t use any concurrency primitives, which can lead to make sure changes to counter can’t be interrupted by another thread
  • Arc uses a concurrency primitive called atomic, which makes Mutex shareable across threads

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());
}