19、探索Rust中的并发编程

探索Rust中的并发编程

1. 并发编程简介

在当今的计算环境中，我们经常会遇到需要程序快速做出决策或在短时间内处理大量数据的情况。比如，当你在下载文件、听音乐、和朋友聊天以及在后台打印文件时，操作系统就在后台管理着这些任务，在不同的处理器（CPU）上调度它们。这就是并发编程在实际中的体现。

并发编程允许程序同时执行多个任务，这在很多场景下是必不可少的。例如，自动驾驶汽车需要同时处理来自各种传感器的输入、规划车辆路径并向执行器发送指令；网页浏览器需要在处理用户输入的同时逐步渲染网页；网站需要处理多个用户的并发请求；网络爬虫需要同时访问数千个网站以收集信息。

1.1 并发与并行的区别

在深入了解并发编程之前，我们需要明确两个相关的概念：并发和并行。

执行模式	描述	示例	适用场景
顺序执行	任务按顺序依次执行，一个任务完成后才开始下一个任务。	一个进程有任务A和任务B，任务A有子任务A1、A2、A3，任务B有子任务B1、B2，先依次执行A1、A2、A3，再执行B1、B2。	对任务执行顺序有严格要求，且任务之间相互依赖的场景。
并发执行	多个任务在逻辑上同时执行，通过任务的交替执行来实现。	任务A和任务B的子任务交替执行，即使A2被阻塞，也可以继续执行其他子任务。	I/O密集型场景，如网络请求、文件读写等。
并行执行	多个任务在物理上同时执行，在不同的CPU处理器或核心上运行。	任务A和任务B在不同的CPU核心上同时执行。	计算密集型场景，如图形处理、气象模拟等。

1.2 多线程的概念

在Unix系统中，线程是进程执行多个任务的一种机制。一个Unix进程从一个主线程开始，但可以创建额外的线程。这些线程可以在单处理器系统中并发执行，也可以在多处理器系统中并行执行。

每个线程都有自己的栈，用于存储局部变量和函数参数，同时也维护自己的寄存器状态。所有线程共享进程的内存地址空间，包括数据段和程序代码。

使用多线程的优点是数据共享方便，线程创建和上下文切换速度快。但也存在一些挑战，比如共享函数需要是线程安全的，对共享数据的访问需要仔细同步，线程中的错误可能会影响其他线程甚至整个进程，而且线程执行顺序的不确定性可能导致数据竞争、死锁等难以调试的问题。

graph LR
    classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px;
    classDef thread fill:#FFF6CC,stroke:#FFBC52,stroke-width:2px;

    A(进程):::process --> B(主线程):::thread
    A --> C(线程1):::thread
    A --> D(线程2):::thread
    A --> E(线程3):::thread

2. 在Rust中创建和配置线程

Rust实现了1:1的线程模型，即每个操作系统线程对应一个由Rust标准库创建的用户级线程。Rust标准库中用于线程相关功能的模块是 std::thread 。

2.1 使用 thread::spawn 函数创建线程

thread::spawn 函数是创建新线程的一种方式。以下是一个简单的示例：

use std::thread;

fn main() {
    for _ in 1..5 {
        thread::spawn(|| {
            println!("Hi from thread id {:?}",
                thread::current().id());
        });
    }
}

在这个示例中，我们在 main 函数中创建了四个子线程。每个子线程打印自己的线程ID。然而，当你运行这个程序时，你会发现输出结果并不稳定，有时可能只看到一行输出，有时可能看到多行，甚至可能看不到任何输出。这是因为线程的执行顺序是不确定的，而且如果 main 函数在子线程执行之前结束，你就不会看到预期的输出。

为了解决这个问题，我们可以使用 join 方法将子线程加入到主线程中，确保主线程等待所有子线程执行完毕后再退出。修改后的代码如下：

use std::thread;

fn main() {
    let mut child_threads = Vec::new();
    for _ in 1..5 {
        let handle = thread::spawn(|| {
            println!("Hi from thread id {:?}",
                thread::current().id());
        });
        child_threads.push(handle);
    }
    for i in child_threads {
        i.join().unwrap();
    }
}

运行修改后的程序，你会看到每次都会输出四行，每行对应一个线程的ID。但线程的执行顺序仍然是不确定的。

2.2 使用 thread::Builder 创建线程

thread::spawn 函数使用默认的线程名称和栈大小。如果你想显式设置这些参数，可以使用 thread::Builder 。以下是使用 thread::Builder 重写的示例：

use std::thread;

fn main() {
    let mut child_threads = Vec::new();
    for i in 1..5 {
        let builder =
            thread::Builder::new().name(format!(
                "mythread{}", i));
        let handle = builder
           .spawn(|| {
                println!("Hi from thread id {:?}", thread::
                    current().name().unwrap());
            })
           .unwrap();
        child_threads.push(handle);
    }
    for i in child_threads {
        i.join().unwrap();
    }
}

在这个示例中，我们使用 thread::Builder 创建了一个线程构建器对象，并通过 name 方法设置了线程的名称。然后使用 spawn 方法创建新线程，并将返回的线程句柄存储在 child_threads 向量中。最后，通过 join 方法等待所有子线程执行完毕。

3. 总结

通过本文，我们了解了并发编程的重要性，以及并发和并行的区别。我们还学习了在Unix系统中多线程的概念，以及如何在Rust中使用 std::thread 模块创建和配置线程。在后续的学习中，我们还将探讨线程中的错误处理、线程间的消息传递、共享状态下的并发以及使用定时器暂停线程执行等内容。

4. 线程中的错误处理

在并发编程中，线程可能会因为各种原因出现错误，如访问无效内存、网络请求失败等。因此，正确处理线程中的错误至关重要。

在 Rust 中， thread::spawn 函数返回一个 JoinHandle 类型，它实现了 Result 类型。当线程正常结束时， JoinHandle 会返回 Ok ，包含线程的返回值；当线程出现错误时， JoinHandle 会返回 Err 。

以下是一个简单的示例，展示了如何处理线程中的错误：

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        // 模拟一个可能出错的操作
        let result = 1 / 0; // 这里会触发除零错误
        result
    });

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

在这个示例中，线程内部进行了除零操作，会触发一个 panic 。在主线程中，我们使用 match 语句来处理 JoinHandle 的结果。如果线程正常结束，会输出 Thread executed successfully ；如果线程出现错误，会输出错误信息。

4.1 错误处理的最佳实践

• 避免在子线程中使用 panic ： panic 会导致线程崩溃，如果在子线程中使用 panic ，可能会影响其他线程或整个进程。建议使用 Result 类型来处理可能的错误。
• 及时捕获和处理错误 ：在主线程中，应该及时捕获子线程的错误，并进行相应的处理，避免错误信息丢失。

5. 线程间的消息传递

在并发编程中，线程之间经常需要进行数据交换和同步。Rust 提供了 std::sync::mpsc 模块，用于实现多生产者单消费者（MPSC）的消息传递机制。

5.1 使用 mpsc 模块进行消息传递

以下是一个简单的示例，展示了如何使用 mpsc 模块进行线程间的消息传递：

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

fn main() {
    // 创建一个通道，返回发送者和接收者
    let (tx, rx) = mpsc::channel();

    // 创建一个子线程
    let handle = thread::spawn(move || {
        // 发送消息到通道
        tx.send("Hello from thread!").unwrap();
    });

    // 从通道接收消息
    let received = rx.recv().unwrap();
    println!("Received: {}", received);

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

在这个示例中，我们首先使用 mpsc::channel 函数创建了一个通道，返回一个发送者 tx 和一个接收者 rx 。然后，我们创建了一个子线程，在子线程中使用发送者 tx 发送一条消息。在主线程中，使用接收者 rx 从通道中接收消息，并打印出来。最后，等待子线程结束。

5.2 多生产者的情况

mpsc 模块支持多生产者，即多个线程可以同时向同一个通道发送消息。以下是一个多生产者的示例：

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

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

    // 创建多个子线程
    let threads: Vec<_> = (0..3).map(|i| {
        let tx_clone = tx.clone();
        thread::spawn(move || {
            tx_clone.send(format!("Message from thread {}", i)).unwrap();
        })
    }).collect();

    // 从通道接收消息
    for received in rx {
        println!("Received: {}", received);
    }

    // 等待所有子线程结束
    for thread in threads {
        thread.join().unwrap();
    }
}

在这个示例中，我们创建了三个子线程，每个子线程都克隆了一个发送者 tx_clone ，并向通道发送一条消息。在主线程中，使用 for 循环从通道中接收消息，直到通道关闭。最后，等待所有子线程结束。

graph LR
    classDef thread fill:#FFF6CC,stroke:#FFBC52,stroke-width:2px;
    classDef channel fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px;

    A(线程1):::thread --> B(通道):::channel
    C(线程2):::thread --> B
    D(线程3):::thread --> B
    B --> E(主线程):::thread

6. 共享状态下的并发

在并发编程中，多个线程可能会同时访问和修改共享状态。如果不进行适当的同步，可能会导致数据竞争、死锁等问题。Rust 提供了一些机制来确保共享状态下的并发安全。

6.1 使用互斥锁（Mutex）

互斥锁是一种最常用的同步机制，用于保护共享资源，确保同一时间只有一个线程可以访问该资源。以下是一个使用互斥锁的示例：

use std::sync::{Mutex, Arc};
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());
}

在这个示例中，我们使用 Arc （原子引用计数）来共享一个 Mutex 类型的计数器。每个子线程都会克隆一个 Arc 并尝试获取互斥锁，对计数器进行加一操作。最后，在主线程中打印计数器的最终值。

6.2 使用读写锁（RwLock）

读写锁允许多个线程同时进行读操作，但在进行写操作时会独占锁。以下是一个使用读写锁的示例：

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

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

    // 多个读线程
    for _ in 0..5 {
        let data = Arc::clone(&data);
        let handle = thread::spawn(move || {
            let num = data.read().unwrap();
            println!("Read: {}", *num);
        });
        handles.push(handle);
    }

    // 一个写线程
    let data = Arc::clone(&data);
    let handle = thread::spawn(move || {
        let mut num = data.write().unwrap();
        *num += 1;
        println!("Write: {}", *num);
    });
    handles.push(handle);

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

在这个示例中，我们创建了多个读线程和一个写线程。读线程可以同时获取读锁进行读操作，而写线程需要独占写锁进行写操作。

7. 使用定时器暂停线程执行

在某些情况下，我们可能需要暂停线程的执行一段时间。Rust 提供了 std::thread::sleep 函数来实现这个功能。

以下是一个简单的示例，展示了如何使用 sleep 函数暂停线程执行：

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

fn main() {
    println!("Before sleep");
    thread::sleep(Duration::from_secs(2));
    println!("After sleep");
}

在这个示例中，主线程会暂停执行 2 秒，然后继续执行后续代码。

7.1 定时器的应用场景

• 定时任务 ：例如，定时检查系统状态、定时清理缓存等。
• 延迟操作 ：例如，在用户点击按钮后，延迟一段时间再执行某个操作。

8. 总结

本文深入探讨了 Rust 中的并发编程，包括线程中的错误处理、线程间的消息传递、共享状态下的并发以及使用定时器暂停线程执行等内容。通过学习这些知识，我们可以编写更加安全、高效的并发程序。在实际应用中，需要根据具体的需求选择合适的并发机制，并注意避免并发编程中常见的问题，如数据竞争、死锁等。希望本文能帮助你更好地掌握 Rust 中的并发编程。