Threads overview in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust thread code?

Consider the following Rust program that creates a thread and prints a message. What will it print?

Rust

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("Hello from the thread!");
    });
    handle.join().unwrap();
    println!("Hello from the main thread!");
}

A Hello from the main thread!\nHello from the thread!

B Hello from the thread!\nHello from the main thread!

C Hello from the thread!

D Hello from the main thread!

💡 Hint

Remember that join() waits for the thread to finish before continuing.

The spawned thread prints first, then join() waits for it to finish. After that, the main thread prints its message.

🧠 Conceptual

intermediate

Which statement about Rust threads is true?

Choose the correct statement about Rust threads.

A Rust threads require explicit synchronization to share data safely.

B Rust threads automatically clone all variables from the main thread.

C Rust threads cannot be joined once spawned.

D Rust threads share memory by default without any safety checks.

💡 Hint

Think about Rust's ownership and safety guarantees.

Rust enforces safe concurrency by requiring explicit synchronization (like Mutex or channels) to share data between threads.

🔧 Debug

advanced

What error does this Rust thread code produce?

Examine the code below. What error will the Rust compiler report?

Rust

use std::thread;

fn main() {
    let v = vec![1, 2, 3];
    let handle = thread::spawn(|| {
        println!("{:?}", v);
    });
    handle.join().unwrap();
}

A No error, prints [1, 2, 3]

B error: use of moved value `v`

C error: closure may outlive the current function, but it borrows `v`, which is owned by the current function

D error: expected `FnOnce` closure, found `FnMut` closure

💡 Hint

Think about how closures capture variables and thread lifetimes.

The closure borrows `v` but the thread may outlive `v`'s scope, so Rust prevents this with a lifetime error.

❓ Predict Output

advanced

What is the output of this Rust thread code with move closure?

What will this Rust program print?

Rust

use std::thread;

fn main() {
    let v = vec![10, 20, 30];
    let handle = thread::spawn(move || {
        println!("{:?}", v);
    });
    handle.join().unwrap();
}

A error: use of moved value `v`

B error: closure does not implement `FnOnce`

C []

D [10, 20, 30]

💡 Hint

Consider what the move keyword does to variable capture.

The move keyword transfers ownership of v into the closure, so it can safely be used inside the thread.

🧠 Conceptual

expert

Which Rust synchronization primitive allows multiple threads to read but only one to write at a time?

Choose the synchronization primitive that permits multiple readers or one writer concurrently.

A RwLock

B AtomicBool

C Mutex

D Condvar

💡 Hint

Think about read-write locks.

RwLock allows multiple readers or one writer at a time, enabling more concurrency than a Mutex.