Threads overview in Rust - Step-by-Step Execution

Concept Flow - Threads overview

Start main thread

↓

Create new thread

↓

New thread runs code

↓

Main thread continues

↓

Wait for new thread to finish (join)

↓

Both threads done, program ends

This flow shows how the main thread starts, creates a new thread that runs concurrently, and then waits for it to finish before ending.

Execution Sample

Rust

use std::thread;

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

This Rust program creates a new thread that prints a message, then waits for it to finish before exiting.

Execution Table

Step	Action	Thread	Output	State
1	Start main function	Main		Main thread running
2	Create new thread with thread::spawn	Main		New thread created, running concurrently
3	New thread runs closure	New	Hello from new thread!	New thread prints message
4	Main thread continues after spawn	Main		Main thread waiting to join
5	Main thread calls join()	Main		Main thread waits for new thread to finish
6	New thread finishes execution	New		New thread ends
7	join() returns, main thread resumes	Main		Main thread continues
8	Main function ends	Main		Program ends

💡 Program ends after main thread joins new thread and both finish execution

Variable Tracker

Variable	Start	After Step 2	After Step 5	Final
handle	None	Thread handle created	Thread joined	Thread handle dropped

Key Moments - 2 Insights

Why does the main thread need to call join() on the new thread?

Without join(), the main thread might finish and exit the program before the new thread runs or finishes, as shown in step 5 of the execution_table where join() makes the main thread wait.

Does the new thread run before or after the main thread continues?

The new thread runs concurrently with the main thread. Step 3 shows the new thread printing while step 4 shows the main thread continuing, so they overlap in time.

Visual Quiz - 3 Questions

Look at the execution_table, at which step does the new thread print its message?

A Step 5

B Step 2

C Step 3

D Step 7

💡 Hint

Check the Output column in execution_table rows for the print message

At which step does the main thread wait for the new thread to finish?

A Step 5

B Step 4

C Step 6

D Step 8

💡 Hint

Look for the join() call in the Action column of execution_table

If we remove handle.join(), what would happen to the program flow?

A New thread never runs

B Main thread might finish before new thread

C Main thread waits anyway

D Program crashes

💡 Hint

Refer to key_moments about why join() is needed to wait for new thread

Concept Snapshot

Threads overview in Rust:
- Use thread::spawn to create a new thread
- New thread runs closure concurrently
- Main thread continues immediately
- Use join() to wait for new thread to finish
- Program ends after all threads complete

Full Transcript

This example shows how Rust handles threads. The main thread starts and creates a new thread using thread::spawn. The new thread runs its code concurrently, printing a message. Meanwhile, the main thread continues and then calls join() to wait for the new thread to finish. After the new thread ends, join() returns and the main thread finishes, ending the program. This ensures both threads complete before exit.

Practice

1. What is the main purpose of using threads in Rust?

easy

A. To make the program run slower

B. To avoid using variables

C. To write code without functions

D. To run multiple parts of a program at the same time

Solution

1. Step 1: Understand what threads do

   Threads allow a program to perform multiple tasks simultaneously, improving efficiency.

2. Step 2: Match purpose with options

   Only To run multiple parts of a program at the same time correctly states that threads run parts of a program at the same time.

3. Final Answer:

   To run multiple parts of a program at the same time -> Option D

4. Quick Check:

   Threads = run tasks simultaneously [OK]

Hint: Threads let programs do many things at once [OK]

Common Mistakes:

• Thinking threads slow down the program
• Confusing threads with functions
• Believing threads remove variables

2. Which of the following is the correct way to start a new thread in Rust?

easy

A. thread::start(|| println!("Hello"));

B. thread::spawn(|| println!("Hello"));

C. thread::run(|| println!("Hello"));

D. thread::create(|| println!("Hello"));

Solution

1. Step 1: Recall Rust thread syntax

   Rust uses thread::spawn to create a new thread.

2. Step 2: Compare options with correct syntax

   Only thread::spawn(|| println!("Hello")); uses thread::spawn correctly.

3. Final Answer:

   thread::spawn(|| println!("Hello")); -> Option B

4. Quick Check:

   Start thread = thread::spawn [OK]

Hint: Use thread::spawn to start threads in Rust [OK]

Common Mistakes:

• Using thread::start instead of spawn
• Using thread::run or thread::create which don't exist
• Missing the closure syntax ||

3. What will the following Rust code print?

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("Inside thread");
    });
    handle.join().unwrap();
    println!("Thread finished");
}

medium

A. Inside thread
Thread finished

B. Thread finished

C. Inside thread

D. Thread finished
Inside thread

Solution

1. Step 1: Understand thread::spawn and join

   The thread prints "Inside thread". The main thread waits for it to finish using join().

2. Step 2: Determine print order

   Because join() waits, "Inside thread" prints first, then "Thread finished" prints.

3. Final Answer:

   Inside thread Thread finished -> Option A

4. Quick Check:

   join() waits, so inside thread prints before main [OK]

Hint: join() waits for thread, so thread prints before main continues [OK]

Common Mistakes:

• Assuming main prints first without waiting
• Ignoring join() effect
• Expecting only one print line

4. Identify the error in this Rust code that uses threads:

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("Hello from thread");
    });
    println!("Main thread");
}

medium

A. Missing call to join(), so main may end before thread finishes

B. thread::spawn is used incorrectly

C. println! macro is used wrong

D. No error, code runs perfectly

Solution

1. Step 1: Check thread usage

   The code starts a thread but does not wait for it to finish with join().

2. Step 2: Understand consequences

   Without join(), the main thread may finish and exit before the spawned thread prints.

3. Final Answer:

   Missing call to join(), so main may end before thread finishes -> Option A

4. Quick Check:

   Always join threads to ensure they complete [OK]

Hint: Always join threads to wait for their completion [OK]

Common Mistakes:

• Forgetting to call join()
• Thinking thread::spawn syntax is wrong
• Assuming println! is incorrect

5. You want to run two threads that each print a message, then print "Done" after both finish. Which code correctly does this?

hard

A. thread::spawn(|| println!("Thread 1")).join().unwrap();
thread::spawn(|| println!("Thread 2"));
println!("Done");

B. let t1 = thread::spawn(|| println!("Thread 1"));
let t2 = thread::spawn(|| println!("Thread 2"));
println!("Done");

C. let t1 = thread::spawn(|| println!("Thread 1"));
let t2 = thread::spawn(|| println!("Thread 2"));
t1.join().unwrap();
t2.join().unwrap();
println!("Done");

D. thread::spawn(|| println!("Thread 1"));
thread::spawn(|| println!("Thread 2"));
thread::spawn(|| println!("Done"));

Solution

1. Step 1: Understand thread creation and waiting

   To ensure "Done" prints after both threads finish, we must join both threads before printing.

2. Step 2: Analyze options for correct join usage

   let t1 = thread::spawn(|| println!("Thread 1")); let t2 = thread::spawn(|| println!("Thread 2")); t1.join().unwrap(); t2.join().unwrap(); println!("Done"); creates two threads, joins both, then prints "Done". This guarantees order.

3. Final Answer:

   let t1 = thread::spawn(|| println!("Thread 1")); let t2 = thread::spawn(|| println!("Thread 2")); t1.join().unwrap(); t2.join().unwrap(); println!("Done"); -> Option C

4. Quick Check:

   Join all threads before final print to ensure order [OK]

Hint: Join all threads before final action to ensure completion [OK]

Common Mistakes:

• Not joining threads before printing "Done"
• Joining threads immediately after spawn (serializing)
• Spawning extra thread for "Done" message