Creating threads in Rust - Practice Exercises

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!

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

C Hello from the thread!

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

💡 Hint

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

The spawned thread prints its message first. The main thread waits for it to finish by calling join(), then prints its own message.

❓ Predict Output

intermediate

What happens if you don't join a thread?

Look at this Rust program that spawns a thread but does not join it. What will be the output?

Rust

use std::thread;
use std::time::Duration;

fn main() {
    thread::spawn(|| {
        thread::sleep(Duration::from_millis(50));
        println!("Thread done");
    });
    println!("Main done");
}

A Main done

B Thread done\nMain done

C Main done\nThread done

D Thread done

💡 Hint

The main thread may finish before the spawned thread prints anything.

Because the main thread does not wait for the spawned thread, the program may end before the spawned thread runs its print statement.

🔧 Debug

advanced

Why does this Rust thread code fail to compile?

Examine this Rust code that tries to spawn a thread using a variable from the main thread. Why does it fail to compile?

Rust

use std::thread;

fn main() {
    let s = String::from("hello");
    let handle = thread::spawn(|| {
        println!("{}", s);
    });
    handle.join().unwrap();
}

A The 'join' method is called incorrectly without handling the Result.

B The variable 's' is not mutable, so it cannot be used inside the thread.

C The thread::spawn function requires the closure to return a value, but this closure returns nothing.

D The closure does not have the 'move' keyword, so it cannot capture 's' by value for the thread.

💡 Hint

Think about how variables are captured by closures when spawning threads.

Rust requires the closure passed to thread::spawn to have the move keyword to take ownership of captured variables. Without move, the closure tries to borrow 's', which is not allowed because the thread may outlive the main function's stack frame.

📝 Syntax

advanced

Which option correctly creates and joins multiple threads in Rust?

Choose the code snippet that correctly creates 3 threads, each printing its index, and waits for all to finish.

A

let mut handles = vec![];
for i in 0..3 {
    let handle = thread::spawn(|| {
        println!("Thread {}", i);
    });
    handles.push(handle);
}
for handle in handles {
    handle.join().unwrap();
}

B

let mut handles = vec![];
for i in 0..3 {
    let handle = thread::spawn(move || {
        println!("Thread {}", i);
    });
    handles.push(handle);
}
for handle in handles {
    handle.join();
}

C

let mut handles = vec![];
for i in 0..3 {
    let i = i;
    let handle = thread::spawn(move || {
        println!("Thread {}", i);
    });
    handles.push(handle);
}
for handle in handles {
    handle.join().unwrap();
}

D

let mut handles = vec![];
for i in 0..3 {
    let handle = thread::spawn(|| {
        println!("Thread {}", i);
    });
    handles.push(handle);
}
for handle in handles {
    handle.join();
}

💡 Hint

Remember to use move to capture the loop variable correctly and to unwrap the join result.

Option C uses move to capture i by value inside the closure, avoiding borrowing issues. It also calls join().unwrap() to handle errors properly.

🚀 Application

expert

What is the output of this Rust program using thread::scope?

This Rust program uses thread::scope to spawn threads that borrow a variable. What will it print?

Rust

use std::thread;

fn main() {
    let data = vec![1, 2, 3];
    thread::scope(|s| {
        for &num in &data {
            s.spawn(|| {
                println!("Number: {}", num);
            });
        }
    });
}

A Number: 1\nNumber: 2\nNumber: 3

B Number: 3\nNumber: 2\nNumber: 1

C Compilation error due to borrowing 'data' inside threads

D Runtime panic due to data being moved

💡 Hint

thread::scope allows threads to borrow variables safely.

The thread::scope function lets spawned threads borrow variables from the stack safely because it waits for all threads to finish before returning. The threads print each number in the vector. The order may vary but usually matches the loop order.