Concurrency Building Blocks

Mutex Counter

Lock Before Updating

Mutex protects shared data by requiring a lock before code can read or change the value.

Program

Play the program to choose the increment added while the counter is locked.

increment
mutex_counter.rs
Replay: real traced execution (multi-file project)
use std::sync::Mutex;

fn main() {
    let increment = 2;
    let counter = Mutex::new(10);
    {
        let mut value = counter.lock().unwrap();
        *value += increment;
    }
    let total = *counter.lock().unwrap();
    println!("total={total}");
}

use std::sync::Mutex;

fn main() {
    let increment = 1;
    let counter = Mutex::new(10);
    {
        let mut value = counter.lock().unwrap();
        *value += increment;
    }
    let total = *counter.lock().unwrap();
    println!("total={total}");
}

use std::sync::Mutex;

fn main() {
    let increment = 5;
    let counter = Mutex::new(10);
    {
        let mut value = counter.lock().unwrap();
        *value += increment;
    }
    let total = *counter.lock().unwrap();
    println!("total={total}");
}

  1. increment ← 2, counter ← Mutex { data: 10, poisoned: false, .. }

    3fn main() {4    let incremen→ 2t = 2; //@increment=2, 1, 55    let counte→ Mutex { data: 10, poisoned: false, .. }r = Mutex::new(10);6    {7        let mut valu→ 10e = counter.lock().unwrap();8        *valu→ 12e += incremen2t;9    }10    let tota→ 12l = *counter.lock().unwrap();11    println!("total={total}");12}
    outputtotal=12

  1. increment ← 1, counter ← Mutex { data: 10, poisoned: false, .. }

    3fn main() {4    let incremen→ 1t = 1;5    let counte→ Mutex { data: 10, poisoned: false, .. }r = Mutex::new(10);6    {7        let mut valu→ 10e = counter.lock().unwrap();8        *valu→ 11e += incremen1t;9    }10    let tota→ 11l = *counter.lock().unwrap();11    println!("total={total}");12}
    outputtotal=11

  1. increment ← 5, counter ← Mutex { data: 10, poisoned: false, .. }

    3fn main() {4    let incremen→ 5t = 5;5    let counte→ Mutex { data: 10, poisoned: false, .. }r = Mutex::new(10);6    {7        let mut valu→ 10e = counter.lock().unwrap();8        *valu→ 15e += incremen5t;9    }10    let tota→ 15l = *counter.lock().unwrap();11    println!("total={total}");12}
    outputtotal=15
Mutex `Mutex::new` wraps data that should be updated through a lock.
lock `lock().unwrap()` returns a guard that grants access while it is in scope.
scope The inner block releases the first lock before the final read.