Rust 并发编程基础：多线程、互斥、读写锁、消息通信

最新推荐文章于 2025-04-30 14:05:42 发布

谷雨の梦

最新推荐文章于 2025-04-30 14:05:42 发布

阅读量3.2k

点赞数 1

分类专栏： Rust 文章标签： Rust

本文链接：https://blog.youkuaiyun.com/guyu2019/article/details/124037269

版权

本文介绍了Rust中的并发编程基础，包括线程创建、数据共享以及并发模型。重点讲解了线程间的互斥锁（Mutex）和读写锁（RwLock）的使用，以及通过消息传递实现线程间通信的方法。通过示例代码展示了如何在Rust中安全地进行多线程编程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

线程基础

每个程序都以一个主线程开始启动。主线程可以生成一个新线程，该线程将成为其子线程，子线程可以进一步产生自己的线程。

Rust 中最简单的多线程大概就是使用 thread::spawn:

use std::thread;

fn fibonacci(n: u32) -> u32 {
   
    if n == 0 {
   
        return 0;
    } else if n == 1 {
   
        return 1;
    } else {
   
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

fn main() {
   
    thread::spawn(|| {
   
        let f = fibonacci(30);
        println!("Hello from a thread!. fibonacci(30) = {}", f);
    });
    println!("Hello, world!");
}

运行这段代码，会发现闭包内的函数结果并没有被输出：

Hello, world!

子线程是以分离状态创建的，程序执行到 println! 后就结束了，而相对耗时的子线程并没有结束。如果想要看到正确的结果，需要等待子线程。thread::spawn 返回一个 JoinHandle 类型的值，可以将它存放到变量中。这个类型相当于子线程的句柄，用于连接线程。如果忽略它，就没有办法等待线程。

fn main() {
   
    let child = thread::spawn(|| {
   
        let f = fibonacci(30);
        println!("Hello from a thread!. fibonacci(30) = {}", f);
        f
    });

    println!("Hello, world!");
    let v = child.join().expect("Could not join child thread");
    println!("value: {:?}", v);
}

join 返回一个 Result，可以使用 expect 方法来获取返回值。这样主线程就会等待子线程完成，而不会先结束程序了，就可以看到我们想要的结果：

Hello, world!
Hello from a thread!. fibonacci(30) = 832040
value: 832040

自定义线程

还可以通过 thread 中的 Builder 设置线程的属性来配置线程的 API，例如名称或者堆栈的大小。如果有panic! 会输出对应的调试信息，就可以看到线程名称。

fn main() {
   
    let my_thread = Builder::new()
    .name("my_thread".to_string())
    .stack_size(1024 * 4)
    .spawn(move || {
   
        let v = fibonacci(30);
        println!("fibonacci(30) = {}", fibonacci(30));
        v
    });

    println!("Hello, world!");
    let v = my_thread.unwrap().join().expect

最低0.47元/天解锁文章