Rust Threads

What Are Threads?

Threads are independent units of execution within a program. They allow a program to perform multiple tasks simultaneously. For example, you can use threads to process large datasets while maintaining a responsive user interface.

Rust’s Thread Model

Rust ensures thread safety by applying its ownership rules at compile time. This prevents issues like data races, which occur when two threads access the same data simultaneously, and at least one thread modifies it. Rust’s approach makes multithreading safer and more reliable than in many other programming languages.

Creating Threads in Rust

Rust’s std::thread module provides tools for creating threads. The thread::spawn function is commonly used to start a new thread.

Example: Basic Thread Creation

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..5 {
            println!("Hello from the spawned thread: {}", i);
        }
    });

    for i in 1..5 {
        println!("Hello from the main thread: {}", i);
    }

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

Explanation:

• thread::spawn creates a new thread.
• join() ensures the main thread waits for the spawned thread to finish before exiting.

Passing Data to Threads

When creating threads, you can pass data to them. Rust ensures thread safety by requiring either ownership transfer or proper reference handling.

Example: Passing Ownership

use std::thread;

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

    let handle = thread::spawn(move || {
        println!("Data in thread: {:?}", data);
    });

    handle.join().unwrap();
}

Explanation:

• The move keyword transfers ownership of data to the spawned thread.
• This avoids conflicts or unexpected behavior when multiple threads access the same data.

Sharing Data Between Threads

If multiple threads need access to the same data, you can use synchronization tools like Arc (atomic reference counter) and Mutex (mutual exclusion lock).

Example: Shared Data with Arc and Mutex

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

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..5 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Final counter value: {}", *counter.lock().unwrap());
}

Explanation:

• Arc: Allows multiple threads to share ownership of the Mutex.
• Mutex: Ensures only one thread can access the data at a time, preventing data races.

Thread Communication

Rust uses channels for communication between threads. Channels enable one thread to send data while another receives it.

Example: Sending Messages Between Threads

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let messages = vec!["Hello", "from", "Rust"];
        for msg in messages {
            tx.send(msg).unwrap();
        }
    });

    for received in rx {
        println!("Received: {}", received);
    }
}

Explanation:

• mpsc::channel: Creates a channel with a sender (tx) and receiver (rx).
• The sender sends data, and the receiver retrieves it.

Handling Panics in Threads

A thread may panic during execution. Rust allows you to handle panics gracefully without crashing the entire program.

Example: Handling Thread Panics

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        panic!("Something went wrong in the thread!");
    });

    match handle.join() {
        Ok(_) => println!("Thread finished successfully."),
        Err(e) => println!("Thread panicked: {:?}", e),
    }
}

Explanation:

• Use join to handle panics safely. The main thread continues even if a spawned thread fails.

Threads vs Async in Rust

While threads are great for parallel execution, Rust also offers async programming for lightweight concurrency. Use threads when tasks require separate execution contexts and async for handling multiple I/O-bound tasks efficiently.