Concurrency safety guarantees in Rust - Mini Project: Build & Apply

Understanding Concurrency Safety Guarantees in Rust

📖 Scenario: You are building a simple Rust program that shares data between multiple threads safely. Rust's concurrency safety guarantees help prevent bugs like data races.

🎯 Goal: Learn how to use Rust's Arc and Mutex to safely share and update data across threads without causing concurrency issues.

📋 What You'll Learn

Create a shared data structure using Arc and Mutex

Spawn multiple threads that access and modify the shared data

Use locking to ensure safe concurrent access

Print the final value of the shared data after all threads finish

💡 Why This Matters

🌍 Real World

Many real-world programs need to share data safely between multiple threads, such as web servers handling many users or background tasks updating shared state.

💼 Career

Understanding Rust's concurrency safety guarantees is essential for systems programming, embedded development, and any job requiring safe, efficient multi-threaded code.

1

Create a shared counter using Arc and Mutex

Write code to create a variable called counter that is an Arc wrapping a Mutex containing the integer 0. This will be the shared counter for threads.

Rust

# Create a shared counter using Arc and Mutex
// Your code here

Hint

Use Arc::new(Mutex::new(0)) to create a thread-safe shared integer starting at 0.

2

Spawn threads and clone the shared counter

Add code to create a vector called handles to store thread handles. Then spawn 5 threads using std::thread::spawn. Inside the loop, clone the counter using Arc::clone(&counter) and move it into the thread closure.

Rust

use std::thread;

let counter = Arc::new(Mutex::new(0));
// Create a vector called handles to store thread handles
// Spawn 5 threads, cloning counter for each thread
// Your code here

Hint

Use a for loop from 0 to 5, clone the counter inside the loop, and spawn threads pushing their handles into handles.

3

Increment the shared counter safely inside each thread

Inside the thread closure, lock the counter mutex using lock().unwrap(). Then increment the value inside the mutex by 1.

Rust

for _ in 0..5 {
    let counter = Arc::clone(&counter);
    let handle = thread::spawn(move || {
        // Lock the mutex and increment the counter
        // Your code here
    });
    handles.push(handle);
}

Hint

Use let mut num = counter.lock().unwrap(); to get a mutable reference, then increment with *num += 1;.

4

Wait for threads to finish and print the final counter value

Use a for loop to join all threads in handles. Then lock the counter mutex and print the final value with println!("Final counter: {}", *counter.lock().unwrap()).

Rust

// Join all threads
// Print the final counter value
// Your code here

Hint

Use handle.join().unwrap(); to wait for each thread, then print the counter value.

Practice

1. Which Rust type is used to safely share ownership of data across multiple threads?

easy

A. Rc

B. Box

C. Arc

D. RefCell

Solution

1. Step 1: Understand ownership sharing in concurrency

   In Rust, Arc (Atomic Reference Counted) allows multiple threads to share ownership safely.

2. Step 2: Compare other options

   Box is for single ownership, Rc is not thread-safe, and RefCell is for interior mutability but not thread-safe.

3. Final Answer:

   Arc -> Option C

4. Quick Check:

   Safe shared ownership across threads = Arc [OK]

Hint: Arc is for thread-safe shared ownership [OK]

Common Mistakes:

• Confusing Rc with Arc for multithreading
• Using Box for shared ownership
• Thinking RefCell is thread-safe

2. Which of the following is the correct syntax to create a Mutex protecting an integer value 5?

easy

A. let m = Mutex::new(5);

B. let m = Mutex(5);

C. let m = new Mutex(5);

D. let m = Mutex::create(5);

Solution

1. Step 1: Recall Mutex creation syntax

   In Rust, you create a Mutex by calling Mutex::new(value).

2. Step 2: Check each option

   Only let m = Mutex::new(5); uses the correct Mutex::new(5) syntax; others are invalid.

3. Final Answer:

   let m = Mutex::new(5); -> Option A

4. Quick Check:

   Mutex creation uses Mutex::new() [OK]

Hint: Use Mutex::new(value) to create a Mutex [OK]

Common Mistakes:

• Omitting ::new when creating Mutex
• Using constructor syntax like Mutex(5)
• Confusing new() with create()

3. What will the following Rust code print?

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

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

    for _ in 0..3 {
        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.lock().unwrap());
}

medium

A. 0

B. 3

C. Compilation error

D. 1

Solution

1. Step 1: Understand the code's concurrency logic

   The code creates 3 threads, each increments the shared counter by 1 inside a Mutex lock.

2. Step 2: Calculate the final counter value

   Each thread adds 1, so total increments = 3. The final print shows 3.

3. Final Answer:

   3 -> Option B

4. Quick Check:

   3 threads incrementing counter = 3 [OK]

Hint: Count threads incrementing inside Mutex lock [OK]

Common Mistakes:

• Ignoring Mutex lock and thinking of race conditions
• Assuming only one thread runs
• Expecting compilation error due to Arc usage

4. Identify the error in this Rust code snippet that tries to share a vector across threads:

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

fn main() {
    let numbers = vec![1, 2, 3];
    let shared_numbers = Arc::new(numbers);

    let handle = thread::spawn(move || {
        shared_numbers.push(4);
    });

    handle.join().unwrap();
}

medium

A. Vector is not thread-safe without Mutex or RwLock

B. Arc does not implement Send for Vec<T>

C. Cannot move vector into Arc

D. Missing clone of Arc before move

Solution

1. Step 1: Examine the thread code

   The thread attempts to mutate the shared Arc<Vec<i32>> by calling push, but Arc provides only shared immutable access.

2. Step 2: Recall requirements for mutable shared data

   To mutate data shared across threads, wrap it in Mutex or RwLock inside the Arc, e.g., Arc<Mutex<Vec<i32>>>.

3. Step 3: Eliminate other options

   A: Vec can be moved into Arc. B: Arc<Vec<T>> implements Send/Sync for T: Sync. D: Clone not needed for single-thread move.

4. Final Answer:

   Vector is not thread-safe without Mutex or RwLock -> Option A

5. Quick Check:

   Mutable shared data needs Mutex or RwLock [OK]

Hint: Mutable shared data needs Mutex or RwLock [OK]

Common Mistakes:

• Thinking Arc alone makes data mutable and safe
• Confusing Send trait errors
• Assuming clone is needed before move

5. You want to safely share and mutate a HashMap across multiple threads in Rust. Which combination of types ensures concurrency safety and allows mutation?

hard

A. Arc<RefCell<HashMap<String, i32>>>

B. Mutex<HashMap<String, i32>>

C. Rc<RefCell<HashMap<String, i32>>>

D. Arc<RwLock<HashMap<String, i32>>>

Solution

1. Step 1: Identify thread-safe shared ownership

   To share data across threads, Arc is needed for atomic reference counting.

2. Step 2: Choose synchronization primitive for mutation

   For mutable access, Mutex or RwLock can be used. RwLock allows multiple readers or one writer, improving concurrency.

3. Step 3: Evaluate options

   Arc<RefCell<HashMap<String, i32>>> uses RefCell which is not Sync and thus not thread-safe. Arc<RwLock<HashMap<String, i32>>> uses RwLock which is suitable for read-heavy workloads with mutations. Rc<RefCell<HashMap<String, i32>>> uses Rc and RefCell, which are not thread-safe. Mutex<HashMap<String, i32>> lacks Arc, so no shared ownership across threads.

4. Final Answer:

   Arc<RwLock<HashMap<String, i32>>> -> Option D

5. Quick Check:

   Arc + RwLock = safe shared mutable access [OK]

Hint: Use Arc with RwLock for shared mutable access [OK]

Common Mistakes:

• Using Rc or RefCell for multithreading
• Omitting Arc for shared ownership
• Choosing Mutex over RwLock without reason