Rust 并发编程学习笔记

前言

Rust 是一门具有内存安全和并发性能的系统编程语言。在 Rust 中，我们可以使用多种方式进行并发编程，例如线程、通道、锁等。本文将介绍 Rust 并发编程相关的知识，并提供一些示例代码。

线程

在 Rust 中，我们可以创建线程来实现并发编程。通过标准库中的 std::thread 模块，我们可以轻松地创建线程。

下面是一个简单的示例代码：

rustCopy Code
use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("Hello from a thread!");
    });

    handle.join().unwrap();
}

上述代码中，我们通过 thread::spawn() 方法创建了一个新的线程，并在其中执行了一个闭包。handle.join() 方法等待子线程执行完毕，并返回其结果。

通道

在 Rust 中，我们可以使用通道来进行线程间的通信。通过标准库中的 std::sync::mpsc 模块，我们可以轻松地创建通道。

下面是一个简单的示例代码：

rustCopy Code
use std::sync::mpsc;
use std::thread;

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

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

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

    handle.join().unwrap();
}

上述代码中，我们创建了一个通道，并在一个线程中将一个字符串发送到通道中。在主线程中，我们通过 rx.recv() 方法等待接收到来自通道的消息，并将其打印出来。

锁

在 Rust 中，我们可以使用锁来保护共享数据的访问。通过标准库中的 std::sync 模块，我们可以轻松地创建锁。

下面是一个简单的示例代码：

rustCopy Code
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());
}

上述代码中，我们创建了一个共享计数器，并使用锁来保护它的访问。在每个线程中，我们通过 counter.lock().unwrap() 方法获取锁，并对计数器进行自增操作。在主线程中，我们通过 *counter.lock().unwrap() 方法获取锁，并打印出计数器的值。

结论

本文介绍了 Rust 并发编程相关的知识，并提供了一些示例代码。通过本文的学习，您应该能够对 Rust 并发编程有更深入的了解，并可以在实际项目中应用这些知识。