**Course Title:** Mastering Rust: From Basics to Systems Programming **Section Title:** Concurrency in Rust **Topic:** Using the std::thread module for creating threads **Introduction** In the previous topic, we introduced the concept of concurrency in Rust and discussed the importance of threads and messages in concurrent programming. In this topic, we will delve deeper into the `std::thread` module, which provides a way to create and manage threads in Rust. We will explore the different types of threads, how to create and spawn threads, and how to handle panics in threads. **Creating and Spawning Threads** In Rust, threads can be created using the `std::thread` module. The `spawn` function creates a new thread and executes a given closure or function in that thread. Here is an example of how to create a new thread and execute a closure: ```rust use std::thread; use std::time::Duration; fn main() { let handle = thread::spawn(|| { for i in 1..10 { println!("Thread: {}", i); thread::sleep(Duration::from_millis(1)); } }); for i in 1..10 { println!("Main: {}", i); thread::sleep(Duration::from_millis(1)); } handle.join().unwrap(); } ``` In this example, we create a new thread using `thread::spawn` and pass a closure that iterates from 1 to 10, printing each number and sleeping for 1 millisecond. In the main thread, we also iterate from 1 to 10, printing each number and sleeping for 1 millisecond. Finally, we call `join` on the thread handle to wait for the thread to finish. **Types of Threads** In Rust, there are two types of threads: **main threads** and **spawned threads**. The main thread is the thread that runs the `main` function, and spawned threads are threads that are created using `thread::spawn`. **Named Thread** It's a good practice to name your threads to help debug and monitoring the running threads. ```rust use std::thread; fn main() { let handle = thread::Builder::new() .name("my_thread".into()) .spawn(|| { // thread code here }); // code here } // or using `std::thread::spawn` use std::thread; fn main() { let handle = thread::spawn(|| { std::thread::current().name().map(|n| println!("thread: {}", n)); // thread code here }); } ``` **Thread Handle** When you spawn a new thread, you get a `JoinHandle` object in return, which you can use to wait for the thread to finish. Here's an example: ```rust use std::thread; fn main() { let handle = thread::spawn(|| { // thread code here }); // Call `join` to block the current thread until the spawned thread has finished. handle.join().unwrap(); } ``` **Returning Values from Threads** If you want to return values from a thread, you can use the `spawn` function with a closure that returns a value. Here is an example: ```rust use std::thread; fn main() { let handle = thread::spawn(|| { // thread code here "Hello, world!" }); // Call `join` to wait for the thread to finish and get the returned value. let result = handle.join().unwrap(); println!("{}", result); } ``` **Panic Handling in Threads** When a thread panics, the entire program crashes by default. To prevent this, you can use the `unwrap` method to handle panics: ```rust use std::thread; fn main() { let handle = thread::spawn(|| { // thread code here panic!("Something went wrong!"); }); // Handle panics using `unwrap`. handle.join().unwrap(); } ``` However, a better way to handle panics is to use `std::panic::catch_unwind`: ```rust use std::panic; use std::thread; fn main() { let handle = thread::spawn(|| { panic::catch_unwind(|| { // thread code here panic!("Something went wrong!"); }); }); // Handle panics using `unwrap`. handle.join().unwrap(); } ``` **Best Practices** When working with threads in Rust, keep the following best practices in mind: * Use meaningful names for your threads to make debugging and monitoring easier. * Always call `join` on a thread handle to ensure the thread is waited on. * Use `catch_unwind` to handle panics in threads. * Use `thread::spawn` to create new threads, and use the `Builder` pattern to customize threads. **Conclusion** In this topic, we learned about the `std::thread` module and how to create threads in Rust. We saw how to spawn threads, handle panics, and work with thread handles. By following best practices and using the techniques we learned, you can write efficient and safe concurrent code in Rust. **Recommended Reading** For more information on the `std::thread` module, you can refer to the [official Rust documentation](https://doc.rust-lang.org/std/thread/index.html). For a deeper dive into concurrency in Rust, we recommend reading the [Concurrency chapter in the Rust Book](https://doc.rust-lang.org/book/ch16-01-threads.html). **Comment/Ask for Help** If you have any questions or need further clarification on any of the topics covered in this section, please leave a comment below. We'll be happy to help. **Next Topic: Shared State Concurrency with Mutex and Arc** In the next topic, we'll explore shared state concurrency using Mutex and Arc. We'll learn how to use Mutex to protect shared state and how to use Arc to create shared ownership.