Rust 中线程 (Thread) 的用法？

推荐答案

在 Rust 中，线程可以通过 std::thread 模块来创建和管理。以下是一个简单的示例，展示了如何创建线程并等待其完成：

// www.javascriptcn.com code example
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));
        }
    });

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

    handle.join().unwrap();
}

在这个示例中，thread::spawn 用于创建一个新线程，并返回一个 JoinHandle。JoinHandle 可以用来等待线程完成。join 方法会阻塞当前线程，直到被调用的线程执行完毕。

本题详细解读

1. 创建线程

在 Rust 中，线程是通过 std::thread::spawn 函数创建的。这个函数接受一个闭包作为参数，闭包中的代码将在新线程中执行。

let handle = thread::spawn(|| {
    // 线程执行的代码
});

2. 线程的返回值

thread::spawn 返回一个 JoinHandle，它允许你等待线程完成并获取线程的返回值。JoinHandle 的 join 方法会阻塞当前线程，直到被调用的线程执行完毕。

handle.join().unwrap();

3. 线程间的通信

Rust 提供了多种线程间通信的方式，最常见的是使用通道（std::sync::mpsc）。通道允许线程之间发送和接收消息。

// www.javascriptcn.com code example
use std::sync::mpsc;
use std::thread;

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

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

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

4. 线程安全

Rust 的所有权系统和类型系统确保了线程安全。通过使用 Arc（原子引用计数）和 Mutex（互斥锁），可以在多个线程之间安全地共享数据。

// www.javascriptcn.com code example
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());
}

5. 线程的局部变量

Rust 提供了 thread_local! 宏，用于定义线程局部变量。每个线程都有自己独立的变量副本。

// www.javascriptcn.com code example
use std::cell::RefCell;
use std::thread;

thread_local! {
    static FOO: RefCell<u32> = RefCell::new(1);
}

fn main() {
    FOO.with(|f| {
        *f.borrow_mut() = 2;
    });

    thread::spawn(|| {
        FOO.with(|f| {
            *f.borrow_mut() = 3;
        });
    }).join().unwrap();

    FOO.with(|f| {
        println!("{}", *f.borrow());
    });
}

通过这些机制，Rust 提供了强大且安全的线程管理功能。