Shared state overview in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code using Arc and Mutex?

Consider this Rust program that shares state between threads using Arc and Mutex. What will it print?

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..5 {
        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!("Counter: {}", *counter.lock().unwrap());
}

A Compilation error due to missing Send trait

B Counter: 5

C Counter: 1

D Counter: 0

💡 Hint

Think about how Arc and Mutex work together to allow safe shared access.

The Arc allows multiple ownership across threads, and Mutex ensures only one thread changes the value at a time. Each thread increments the counter once, so the final value is 5.

🧠 Conceptual

intermediate

Which Rust type is used to share mutable state safely across threads?

In Rust, which combination of types is commonly used to share mutable state safely across multiple threads?

A Arc and Mutex

B Rc and RefCell

C Box and Cell

D Vec and String

💡 Hint

One type provides thread-safe reference counting, the other provides mutual exclusion.

Arc is an atomic reference counter safe for threads, and Mutex provides exclusive mutable access. Together they allow safe shared mutable state.

🔧 Debug

advanced

What error does this Rust code produce when sharing state without synchronization?

What error will this Rust code produce?

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

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

    for _ in 0..5 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            // Trying to increment counter directly
            *counter += 1;
        });
        handles.push(handle);
    }

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

    println!("Counter: {}", *counter);
}

A No error, prints Counter: 5

B error[E0277]: the trait `Send` is not implemented for `i32`

C error[E0382]: use of moved value `counter`

D error[E0596]: cannot borrow data in an Arc as mutable

💡 Hint

Think about mutability and thread safety with Arc.

Arc provides shared ownership but does not allow mutable access directly. Trying to mutate the inner value without synchronization causes a compile-time error.

📝 Syntax

advanced

Which option correctly creates a thread-safe shared counter in Rust?

Choose the Rust code snippet that correctly creates a thread-safe shared counter initialized to zero.

A let counter = Arc::new(Mutex::new(0));

B let counter = Rc::new(RefCell::new(0));

C let counter = Box::new(0);

D let counter = Mutex::new(Arc::new(0));

💡 Hint

Remember which types are thread-safe and which are not.

Arc is thread-safe reference counting, and Mutex allows safe mutable access. Rc and RefCell are not thread-safe.

🚀 Application

expert

How many times is the shared counter incremented in this Rust program?

Given this Rust program, how many times will the shared counter be incremented?

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 || {
            for _ in 0..10 {
                let mut num = counter.lock().unwrap();
                *num += 1;
            }
        });
        handles.push(handle);
    }

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

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

A 1

B 10

C 100

D Compilation error due to deadlock

💡 Hint

Count how many threads and increments each thread performs.

There are 10 threads, each incrementing the counter 10 times, so total increments are 100. The Mutex prevents data races.