Creating threads in Rust - Visual Walkthrough

Concept Flow - Creating threads

Start main thread

↓

Call thread::spawn

↓

Create new thread

↓

Run closure in new thread

↓

Main thread continues

↓

Join new thread

↓

Wait for thread to finish

↓

Program ends

The main thread starts, creates a new thread with thread::spawn, runs code in it, then waits for it to finish with join.

Execution Sample

Rust

use std::thread;

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

This code creates a new thread that prints a message, then the main thread waits for it to finish.

Execution Table

Step	Action	Thread	Output	State
1	Start main function	Main		Main thread running
2	Call thread::spawn with closure	Main		New thread created, running closure
3	New thread runs closure	New Thread	Hello from thread!	Closure executed
4	Main thread continues	Main		Waiting for new thread
5	Call handle.join()	Main		Waiting for new thread to finish
6	New thread finishes	New Thread		Thread ends
7	handle.join() returns	Main		Main thread resumes
8	Main function ends	Main		Program ends

💡 Program ends after main thread waits for spawned thread to finish with join

Variable Tracker

Variable	Start	After thread::spawn	After join	Final
handle	uninitialized	JoinHandle created	join() called and returned	JoinHandle dropped

Key Moments - 3 Insights

Why do we need to call join() on the thread handle?

Calling join() makes the main thread wait for the spawned thread to finish, ensuring the program doesn't end early. See execution_table step 5 and 7.

Does the spawned thread run immediately after thread::spawn?

Yes, the new thread starts running the closure almost immediately after thread::spawn is called, as shown in execution_table step 3.

What happens if we don't call join()?

If join() is not called, the main thread may finish and end the program before the spawned thread completes, possibly cutting it off. This is why join() is important (step 5).

Visual Quiz - 3 Questions

Look at the execution table, what is the output printed by the new thread?

A "Hello from main!"

B "Hello from thread!"

C No output

D "Thread finished"

💡 Hint

Check the Output column at step 3 in the execution_table

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

A Step 3

B Step 2

C Step 5

D Step 7

💡 Hint

Look at the Action and State columns in execution_table steps 5 and 7

If we remove handle.join(), what is likely to happen?

A The program may end before the spawned thread finishes

B The main thread will wait anyway

C The spawned thread will never run

D The program will crash

💡 Hint

Refer to key_moments explanation about join() importance

Concept Snapshot

Creating threads in Rust:
- Use thread::spawn(|| { ... }) to start a new thread
- The closure runs in the new thread immediately
- thread::spawn returns a JoinHandle
- Call join() on JoinHandle to wait for thread completion
- Without join(), main may end before thread finishes

Full Transcript

This example shows how Rust creates threads using thread::spawn. The main thread starts and calls thread::spawn with a closure that prints a message. This creates a new thread that runs the closure immediately. The main thread continues and calls join() on the thread handle to wait for the spawned thread to finish. The program ends after the spawned thread completes. Calling join() is important to prevent the main thread from ending too soon. The variable handle holds the JoinHandle returned by thread::spawn and changes state as join() is called and returns.