Skip to main content

Threads: Creating and Managing Threads

Following our introduction to Fearless Concurrency, this article delves into Threads: Creating and Managing Threads. This is the next logical step in our journey to mastering concurrent programming in Rust.

📚 Prerequisites​

Before we begin, please ensure you have a solid grasp of the following concepts:

  • A conceptual understanding of "Fearless Concurrency" from the previous article.
  • Basic Rust syntax.
  • Ownership and closures.

🎯 Article Outline: What You'll Master​

In this article, you will learn:

  • ✅ Spawning Threads: How to create new threads to run code in parallel.
  • ✅ Joining Threads: How to wait for threads to complete their work.
  • ✅ Moving Data: How to move data to a new thread using move closures.
  • ✅ Thread Safety: A deeper look at how Rust ensures thread safety.

🧠 Section 1: The Core Concepts of Threads​

A thread is the smallest unit of processing that can be performed in an OS. In Rust, we can create new threads to run code concurrently. This is useful for tasks that can be broken down into smaller, independent units of work.

Key Principles:

  • Parallel Execution: Threads allow different parts of your program to run at the same time, which can lead to significant performance improvements on multi-core processors.
  • Isolation: Each thread has its own stack and local variables, which helps to prevent threads from interfering with each other.
  • Shared Memory: Threads can share memory, but this must be done carefully to avoid data races. Rust's ownership system helps to ensure that shared memory is accessed safely.

💻 Section 2: Deep Dive - Implementation and Walkthrough​

2.1 - Spawning a Simple Thread​

Let's start with a basic example of spawning a thread:

// main.rs
use std::thread;
use std::time::Duration;

fn main() {
    thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }
}

Step-by-Step Code Breakdown:

  1. use std::thread;: We import the thread module from the standard library.
  2. thread::spawn(|| { ... });: The thread::spawn function takes a closure as an argument and executes it in a new thread.
  3. thread::sleep(...): This function pauses the execution of the current thread for a specified duration.

2.2 - Waiting for a Thread with join​

In the previous example, the main thread doesn't wait for the spawned thread to finish. To wait for the spawned thread, we can use the join method on the JoinHandle returned by thread::spawn:

// main.rs
use std::thread;
use std::time::Duration;

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    handle.join().unwrap();

    for i in 1..5 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }
}

Walkthrough:

  • let handle = thread::spawn(...): The thread::spawn function returns a JoinHandle.
  • handle.join().unwrap(): The join method blocks the execution of the current thread until the thread associated with the handle has finished.

🛠️ Section 3: Project-Based Example: Moving Data to a Thread​

You can move data to a thread using a move closure:

// main.rs
use std::thread;

fn main() {
    let v = vec![1, 2, 3];

    let handle = thread::spawn(move || {
        println!("Here's a vector: {:?}", v);
    });

    handle.join().unwrap();
}

The Goal: To move a vector from the main thread to a spawned thread and print it.

The Plan:

  1. Create a vector in the main thread.
  2. Spawn a new thread and use a move closure to transfer ownership of the vector to the new thread.
  3. Print the vector from the spawned thread.

Walkthrough:

  • let v = vec![1, 2, 3];: We create a vector in the main thread.
  • thread::spawn(move || { ... });: The move keyword forces the closure to take ownership of the values it uses.

🔬 Section 4: A Deeper Dive: How It Works, Caveats, and Analogies​

4.1 - Under the Hood: The Send Trait​

Rust ensures that only types that are safe to send across thread boundaries can be moved to another thread. This is enforced by the Send marker trait. Most primitive types are Send, and types composed entirely of Send types are also Send.

4.2 - Common Rust Caveats and Pitfalls​

  • Dangling References: The compiler will prevent you from creating a thread that outlives a reference it holds.
  • Panics: If a thread panics, join will return an Err containing the panic payload.

🚀 Section 5: Advanced Techniques and Performance in Rust​

  • Thread Naming: You can name threads using the thread::Builder struct. This can be useful for debugging.
  • Scoped Threads: The thread::scope function allows you to spawn threads that can borrow from the current stack frame.

✨ Section 6: Best Practices and Anti-Patterns in Rust​

Rust Best Practices (Idiomatic Way):

  • Do this: Use thread::spawn for most cases.
  • And this: Use thread::scope when you need to borrow from the current stack frame.
  • And this: Use move closures to transfer ownership of data to threads.

Anti-Patterns (What to Avoid in Rust):

  • Don't do this: Using thread::sleep for synchronization. Use channels or other synchronization primitives instead.

💡 Conclusion & Key Takeaways​

You've learned how to create and manage threads in Rust. This is a fundamental skill for writing concurrent programs.

Let's summarize the key Rust takeaways:

  • Use thread::spawn to create threads.
  • Use JoinHandle::join to wait for threads to finish.
  • Use move closures to transfer ownership of data.

Challenge Yourself (Rust Edition): Write a program that spawns 10 threads. Each thread should print its thread ID and a message.

➡️ Next Steps​

In the next article, "Message Passing to Transfer Data Between Threads with Channels", we'll explore a powerful way to communicate between threads.

Keep building, keep learning, and enjoy your Rust programming adventure!

Glossary (Rust Terms)​

  • Thread: A separate stream of execution.
  • JoinHandle: A handle that allows you to wait for a thread to finish.
  • Send trait: A marker trait that indicates a type is safe to send to another thread.

Further Reading (Rust Resources)​