Creating Threads

Using the std::thread Module to Spawn Threads

In Rust, the std::thread module provides a straightforward way to introduce concurrency by creating and managing threads. Spawning threads allows multiple tasks to execute concurrently, leveraging the computational power of modern multi-core processors. The std::thread::spawn function is at the core of this mechanism.

To spawn a new thread, you pass a closure containing the code you want the new thread to execute. This spawned thread runs concurrently with the main thread, allowing both threads to make progress independently.

use std::thread;

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

    println!("Hello from the main thread!");

    handle.join().unwrap(); // Wait for the spawned thread to finish

In this example, the spawned thread prints a message, while the main thread prints its own message. The join method on the handle returned by thread::spawn ensures that the main thread waits for the spawned thread to finish before proceeding.

Sharing Data Between Threads Using Arc and Mutex

Concurrency often involves multiple threads that need to access and modify shared data. Rust's ownership and borrowing system helps prevent data races, but when mutable access is required, synchronization is necessary. The std::sync::Mutex type, along with the std::sync::Arc (Atomic Reference Counting) smart pointer, facilitates safe concurrent access to shared data.

Consider an example where several threads increment a shared counter using a Mutex:

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let shared_data = Arc::new(Mutex::new(0));

    for _ in 0..10 {
        let data = Arc::clone(&shared_data);
        thread::spawn(move || {
            let mut data = data.lock().unwrap();
            *data += 1;

    thread::sleep(std::time::Duration::from_secs(2)); // Give threads time to finish

    let data = shared_data.lock().unwrap();
    println!("Final value: {}", *data);

In this example, Arc ensures that multiple threads can share ownership of the Mutex, and the Mutex ensures that only one thread can modify the data at a time.

Handling Thread Panics

Threads can panic just like any other Rust code. However, panics in spawned threads do not propagate to the main thread by default. If a panic occurs in a spawned thread and is left unhandled, the thread might terminate abruptly, potentially leaving your program in an inconsistent state.

To handle panics in spawned threads, you can use the std::thread::Builder to set a panic handler. This handler will be called if a panic occurs in the thread, allowing you to gracefully handle errors in your concurrent code.

use std::thread;

fn main() {
    let result = thread::Builder::new()
        .spawn(|| {
            panic!("This thread is panicking!");

    match result {
        Ok(handle) => handle.join().unwrap(),
        Err(_) => println!("Thread panicked!"),

By setting up proper panic handling, you ensure that your concurrent code remains robust and maintains the overall stability of your application.

Creating threads in Rust is a powerful way to introduce concurrency into your programs. The std::thread module simplifies the process of spawning threads and enables concurrent execution. By sharing data between threads using synchronization primitives like Mutex and Arc, you can safely coordinate access to shared resources. Additionally, handling thread panics ensures that your concurrent applications remain resilient and maintainable. In the upcoming sections, we'll explore message passing through channels and delve deeper into synchronization primitives to further enhance your understanding of concurrent programming in Rust.