How is multithreading handled in Rust?

In Rust, multithreading is a core feature. Rust is designed to provide memory-safe concurrent execution. Rust avoids data races through mechanisms such as ownership, borrowing, and lifetimes, which are enforced at compile time. These features make Rust both safe and efficient for multithreading. The following are some primary ways Rust handles multithreading:

1. Using std::thread module to create threads

Rust's standard library provides the std::thread module for creating new threads. Each thread has its own stack and local state, which naturally isolates data and reduces the risk of data sharing.

rust
use std::thread;
use std::time::Duration;

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

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

    handle.join().unwrap();
}

In this example, we create a new thread to print numbers 1 to 9 while the main thread prints numbers 1 to 4 concurrently. The join() function is used to wait for the thread to finish.

2. Using message passing for inter-thread communication

Rust prefers message passing for inter-thread data communication, which avoids shared memory and the need for locks. This is implemented through the std::sync::mpsc (multiple producers, single consumer) module.

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

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

    thread::spawn(move || {
        let message = String::from("Hello");
        tx.send(message).unwrap();
    });

    let received = rx.recv().unwrap();
    println!("Received: {}", received);
}

In this example, we create a sender tx and a receiver rx. The new thread sends a message via tx, and the main thread receives it via rx.

3. Using shared state

Although Rust recommends message passing, shared memory may be necessary in certain cases. To safely use shared memory, Arc (Atomic Reference Counting) and Mutex (Mutual Exclusion Lock) can be used to share and modify data across multiple threads.

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

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

    for _ in 0..10 {
        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!("Result: {}", *counter.lock().unwrap());
}

In this example, we use Mutex to ensure only one thread can modify the data at a time, while Arc ensures multiple threads can safely hold references to the same Mutex.

These are some basic ways Rust handles multithreading. Through these mechanisms, Rust provides powerful and safe concurrent performance.