Rust 线程

Rust 提供了一种强大而安全的方式来处理并发编程。在 Rust 中，线程是管理并发的一种方式。通过使用标准库中的 std::thread 模块，你可以轻松地创建和管理线程。

创建线程

在 Rust 中，创建一个新线程是非常简单的。你需要使用 std::thread::spawn 函数来创建一个新的线程。这个函数接受一个闭包作为参数，并在线程中执行该闭包的代码。

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

fn main() {
    // 创建一个新线程
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("子线程: {}", i);
            thread::sleep(std::time::Duration::from_millis(1));
        }
    });

    // 主线程的代码
    for i in 1..5 {
        println!("主线程: {}", i);
        thread::sleep(std::time::Duration::from_millis(1));
    }

    // 等待子线程结束
    handle.join().unwrap();
}

在这个例子中，我们首先创建了一个新的线程，并且传递给它一个闭包。这个闭包包含了一些简单的循环打印语句。然后，我们在主线程中也运行了类似的循环打印语句。最后，我们使用 join() 方法等待子线程结束，确保程序不会过早退出。

线程间通信

在 Rust 中，线程间通信可以通过多种方式实现。其中一种常见的方法是使用 std::sync::mpsc 模块提供的消息传递机制。这种方法避免了数据竞争问题，并提供了强大的安全性保证。

使用通道（Channel）

通道是一种用于线程间通信的机制。它允许你在不同的线程之间发送和接收数据。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("hi");
        tx.send(val).unwrap();
    });

    // 接收来自通道的数据
    let received = rx.recv().unwrap();
    println!("接收到的数据: {}", received);
}

在这个例子中，我们首先创建了一个通道，并将其拆分为发送端（tx）和接收端（rx）。然后，我们在一个子线程中将一个字符串发送到通道。在主线程中，我们从通道接收数据并打印出来。

使用 Arc 和 Mutex 实现共享可变状态

当需要在多个线程之间共享可变状态时，可以使用 Arc（原子引用计数器）和 Mutex（互斥锁）来实现。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 {
        // 克隆 Arc 来增加引用计数
        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!("最终结果: {}", *counter.lock().unwrap());
}

在这个例子中，我们创建了一个 Arc<Mutex<i32>> 类型的共享变量，并将其初始化为 0。然后，我们创建了 10 个线程，每个线程都对这个共享变量加 1。由于使用了 Mutex，所以这些操作是线程安全的。

线程同步

线程同步是指协调多个线程之间的活动，以避免数据竞争和其他并发问题。Rust 提供了几种工具来帮助你实现线程同步，包括互斥锁（Mutex）、条件变量（Condition Variables）和屏障（Barriers）等。

使用 Mutex 实现同步

如上所述，Mutex 是一种同步原语，用于保护共享数据不被多个线程同时修改。当一个线程获取了互斥锁后，其他线程将无法获取同一互斥锁，直到第一个线程释放它为止。

// www.javascriptcn.com code example
use std::sync::{Arc, Mutex};
use std::thread;

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

    let mut handles = vec![];

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

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

    println!("最终结果: {}", *data.lock().unwrap());
}

这段代码展示了如何使用 Mutex 来保护共享变量。通过在访问共享变量之前获取互斥锁，我们可以确保没有其他线程在同一时间修改该变量。

使用屏障（Barrier）

屏障是一种同步原语，用于阻塞一组线程，直到所有线程都到达屏障点。这在需要协调多个线程的操作时非常有用。

// www.javascriptcn.com code example
use std::sync::{Arc, Barrier};
use std::thread;

fn main() {
    let barrier = Arc::new(Barrier::new(4));
    let mut handles = vec![];

    for _ in 0..3 {
        let b = Arc::clone(&barrier);
        let handle = thread::spawn(move || {
            println!("线程准备就绪");
            b.wait(); // 阻塞直到所有线程都到达这里
            println!("所有线程就绪，继续执行！");
        });
        handles.push(handle);
    }

    // 主线程也需要到达屏障
    println!("主线程准备就绪");
    barrier.wait();
    println!("所有线程就绪，继续执行！");

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

在这个例子中，我们创建了一个屏障，并将其与三个子线程关联起来。主线程和这三个子线程都需要调用 wait() 方法，以等待所有线程都到达屏障点。一旦所有线程都到达屏障点，它们将继续执行。

错误处理

在处理线程时，错误处理非常重要。Rust 的 Result 类型是一个强大的工具，可以帮助你优雅地处理错误。

使用 Result 处理错误

当涉及到线程时，可能会出现各种错误，例如线程无法启动、通道发送失败等。为了处理这些情况，我们可以使用 Result 类型，并在可能出错的地方返回 Result。

// www.javascriptcn.com code example
use std::sync::mpsc;
use std::thread;
use std::sync::Arc;
use std::sync::Mutex;
use std::result::Result;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let (tx, rx) = mpsc::channel();

    // 创建一个新线程
    let handle = thread::spawn(move || {
        if let Err(e) = tx.send("Hello from the new thread!") {
            eprintln!("发送失败：{}", e);
        }
    });

    // 等待子线程结束
    handle.join().map_err(|e| eprintln!("线程错误：{}", e))?;

    // 接收来自通道的数据
    match rx.recv() {
        Ok(msg) => println!("{}", msg),
        Err(e) => eprintln!("接收失败：{}", e),
    }

    Ok(())
}

在这个例子中，我们使用 Result 类型来处理可能发生的错误。如果 send 或 recv 方法失败，我们将捕获错误并打印相应的错误信息。

总结

通过本章的学习，你应该已经掌握了 Rust 中线程的基本概念和常用技术。无论是创建线程、实现线程间通信还是处理线程同步问题，Rust 都提供了丰富的工具和库来支持你的工作。理解这些概念将帮助你构建更高效、更安全的并发应用程序。