Rust语言之多线程

最新推荐文章于 2024-04-25 16:01:50 发布
最新推荐文章于 2024-04-25 16:01:50 发布
阅读量1.4k 收藏 19
点赞数 26
分类专栏： Rust 文章标签： rust 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45963786/article/details/136194236
版权

文章目录

一、简介

多线程 是一种并发执行的技术，它允许一个程序或进程同时执行多个线程。每个线程都是程序执行的一个独立路径，它们可以并行运行，共享进程的资源（如内存空间），但每个线程有自己的指令指针、堆栈和局部变量。多线程的主要目的是提高程序的执行效率，通过同时执行多个任务来充分利用计算机的多核处理器。

  • 在Rust语言中，多线程编程是通过标准库中的std::thread模块来实现的。Rust提供了创建和管理线程的API，以及用于线程间同步和通信的机制，如互斥锁（Mutex）和通道（Channel）。

二、创建线程

1.创建一个线程

use std::thread;  
  
fn main() {  
    // 创建一个新线程  
    let handle = thread::spawn(|| {  
        // 在新线程中执行的代码  
        println!("Hello from a new thread!");  
    });  
  
    // 等待线程结束  
    handle.join().unwrap();  
}

2.创建多个线程

use std::thread;  

fn main() {  
    // 创建一个向量来存储线程的句柄  
    let mut threads = vec![];  
    
    // 创建多个线程  
    for i in 0..5 {  
        // 使用闭包捕获变量i的值  
        let thread_number = i;  
        let handle = thread::spawn(move || {  
            // 在新线程中打印线程编号  
            println!("线程 {} 正在运行", thread_number);  
        });  
    
        // 将线程句柄添加到向量中  
        threads.push(handle);  
    }  
    
    // 等待所有线程完成  
    for handle in threads {  
        handle.join().unwrap();  
    }  

    // 在主线程中打印一些信息  
    for i in 0..5 {  
        println!("主线程打印数字: {}", i);  
    }  
}

# 输出结果：
线程 0 正在运行
线程 1 正在运行
线程 2 正在运行
线程 3 正在运行
线程 4 正在运行
主线程打印数字: 0
主线程打印数字: 1
主线程打印数字: 2
主线程打印数字: 3
主线程打印数字: 4
  • 从输出结果上看，仍然像是顺序执行，所以这里引入一个休眠，让线程执行的时候随机休眠0-3秒。

生成随机数

由于Rust核心语言中没有随机数生成的函数，需要使用rand库来进行

# 首先需要在Cargo.toml中添加以下内容
[dependencies]  
rand = "0.8"

# 然后在代码中用use 引入
use rand::Rng;  
use rand::thread_rng;  
  
fn main() {  
    let mut rng = thread_rng();  
    for _i in 0..10{
        let random_number = rng.gen_range(1..4);  
        println!("随机数是: {}", random_number);  
    }
}
# 结果：
随机数是: 3
随机数是: 1
随机数是: 3
随机数是: 1
随机数是: 3
随机数是: 1
随机数是: 3
随机数是: 2
随机数是: 3
随机数是: 1

随机数生成的区间与循环一样，是一个前闭后开的区间

尝试让程序睡一会儿

use rand::Rng;  
use std::{thread::sleep, time::Duration};  
  
fn main() {  
    // 创建一个随机数生成器  
    let mut rng = rand::thread_rng();  
    // 生成一个0到3之间的随机秒数  
    let random_seconds: u64 = rng.gen_range(0..4);  
    // 将秒数转换为Duration  
    let duration = Duration::from_secs(random_seconds);  
    // 让当前线程睡眠指定的时间  
    sleep(duration);  
    // 之后的代码会在等待后执行  
    println!("等待了 {} 秒", random_seconds);  
}

引入多线程

use rand::Rng;  
use std::{thread::sleep, time::Duration};  
use std::thread;  

fn main() {  
    // 创建一个向量来存储线程的句柄  
    let mut threads = vec![];  
    
    // 创建多个线程  
    for i in 1..=10 {  
        // 使用闭包捕获变量i的值  
        let thread_number = i;  
        let handle = thread::spawn(move || {  
            // 在新线程中打印线程编号  
            println!("线程 {} 正在运行", thread_number);      
            // 创建一个随机数生成器  
            let mut rng = rand::thread_rng();  
            // 生成一个0到3之间的随机秒数  
            let random_seconds: u64 = rng.gen_range(0..4);  
            // 将秒数转换为Duration  
            let duration = Duration::from_secs(random_seconds);  
            // 让当前线程睡眠指定的时间  
            sleep(duration);  
            println!("线程 {} 运行结束,休息了{}秒.", thread_number,random_seconds);  
        });  
    
        // 将线程句柄添加到向量中  
        threads.push(handle);  
    }  
    
    // 等待所有线程完成  
    for handle in threads {  
        handle.join().unwrap();  
    }  

    // 在主线程中打印一些信息  
    for i in 0..5 {  
        println!("主线程打印数字: {}", i);  
    }  
}

# 输出结果
线程 3 正在运行
线程 2 正在运行
线程 5 正在运行
线程 7 正在运行
线程 7 运行结束,休息了0秒.
线程 4 正在运行
线程 6 正在运行
线程 1 正在运行
线程 8 正在运行
线程 9 正在运行
线程 10 正在运行
线程 6 运行结束,休息了1秒.
线程 4 运行结束,休息了1秒.
线程 3 运行结束,休息了1秒.
线程 9 运行结束,休息了1秒.
线程 1 运行结束,休息了2秒.
线程 10 运行结束,休息了2秒.
线程 5 运行结束,休息了2秒.
线程 2 运行结束,休息了3秒.
线程 8 运行结束,休息了3秒.
主线程打印数字: 0
主线程打印数字: 1
主线程打印数字: 2
主线程打印数字: 3
主线程打印数字: 4

三、线程返回值的处理

对于有返回值的多线程来说有两种情况，一种是每个线程处理一个独立的值，用向量接收，另一种是多个线程处理一个值。

1.每个线程处理一个独立的值

use std::thread;  
  
fn main() {  
    let mut handles = vec![];  
  
    for i in 0..5 {  
        let handle = thread::spawn(move || {  
            return i*i;
        });  
        handles.push(handle);  
    }  
  
    let mut results = vec![];  
  
    for handle in handles {  
        match handle.join() {  
            Ok(value) => results.push(value),  
            Err(e) => println!("Thread panicked: {:?}", e),  
        }  
    }  
  
    println!("Results: {:?}", results);  //Results: [0, 1, 4, 9, 16]
}

2.多个线程处理一个值

由于多个线程处理一个值，可能造成条件竞争，属于线程不安全行为，Rust语言中提供了3种处理行为。

  • Arc 只读访问，用于共享只读数据，通过原子引用计数管理生命周期。
  • Mutex 互斥锁，用于保护数据，确保一次只有一个线程可以访问数据（提供独占访问）。
  • RwLock 读写锁，用于保护数据，但允许多个读者同时访问，写者必须独占访问。

Arc（原子引用计数）

Arc是一个提供共享所有权的智能指针。它用于在多个所有者之间共享数据，且只允许对这些数据进行只读访问。Arc通过原子操作维护一个引用计数，确保数据的生命周期至少与最长的所有者一样长。当最后一个Arc指针被丢弃时，其指向的数据也会被释放。

use std::sync::Arc;  
use std::thread;  
  
fn main() {  
    // 创建一个要在多个线程之间共享的值  
    let data = Arc::new(vec![1, 2, 3, 4, 5]);  
  
    // 创建一个向量来存储线程的句柄  
    let mut handles = vec![];  
    println!("Thread {:?} is reading value: {:?}", thread::current().id(), &data); // 主线程的线程ID为 1
    // 创建几个线程来只读访问数据  
    for _i in 0..data.len() {  
        let data = data.clone(); // 克隆Arc以便在线程中使用  
        let handle = thread::spawn(move || {  
            // 获取Vec的引用以便索引  
            // 使用 {:?} 来打印 ThreadId  
            println!("Thread {:?} is reading value: {:?}", thread::current().id(), &data);  
        });  
        handles.push(handle);  
    }  
  
    // 等待所有线程完成  
    for handle in handles {  
        handle.join().unwrap();  
    }  
}
# 运行结果
Thread ThreadId(1) is reading value: [1, 2, 3, 4, 5]
Thread ThreadId(2) is reading value: [1, 2, 3, 4, 5]
Thread ThreadId(3) is reading value: [1, 2, 3, 4, 5]
Thread ThreadId(4) is reading value: [1, 2, 3, 4, 5]
Thread ThreadId(5) is reading value: [1, 2, 3, 4, 5]
Thread ThreadId(6) is reading value: [1, 2, 3, 4, 5]

Mutex（互斥锁）

Mutex是一个提供互斥访问的智能指针。它用于保护数据，确保一次只有一个线程能够访问数据。当一个线程拥有Mutex的锁时，其他尝试获取锁的线程将被阻塞，直到锁被释放。

use std::sync::{Arc, Mutex};  
use std::thread;  
  
fn main() {  
    // 创建一个Arc包裹的互斥锁和值  
    let counter = Arc::new(Mutex::new(1));  
    let mut handles = vec![];  
  
    // 创建几个线程来增加计数器  
    for i in 1..10 {  
        // 克隆Arc智能指针，而不是Mutex或它的值  
        let counter = Arc::clone(&counter);  
        let handle = thread::spawn(move || {  
            // 获取互斥锁以便修改值  
            let mut num = counter.lock().unwrap();  
            *num *=i;
        });  
        handles.push(handle);  
    }  
  
    // 等待所有线程完成  
    for handle in handles {  
        handle.join().unwrap();  
    }  
  
    // 输出最终计数器的值  
    println!("Result: {}", *counter.lock().unwrap());  // Result: 362880
}

RwLock（读写锁）

RwLock是一个提供读写锁定的智能指针。与Mutex不同，RwLock允许多个读者同时访问数据，但写者必须独占锁。当写者拥有锁时，任何尝试获取读锁或写锁的线程都将被阻塞。当没有写者时，可以有多个读者同时访问数据。

use std::sync::{Arc, RwLock};  
  
fn main() {  
    let data = Arc::new(RwLock::new(0));  
    let mut handles = vec![];  
  
    // 创建多个读线程  
    for i in 0..5 {  
        let data = Arc::clone(&data);  
        let handle = std::thread::spawn(move || {  
            let num = data.read().unwrap();  
            println!("Thread {} Reading value: {}", i,*num);  
        });  
        handles.push(handle);  
    }  
  
    // 创建一个写线程  
    let data = Arc::clone(&data);  
    let handle = std::thread::spawn(move || {  
        let mut num = data.write().unwrap();  
        *num += 1;  
        println!("Writing value: {}", *num);  
    });  
    handles.push(handle);  
  
    for handle in handles {  
        handle.join().unwrap();  
    }  
}
# 第一次执行结果
Thread 0 Reading value: 0
Thread 3 Reading value: 0
Thread 1 Reading value: 0
Thread 4 Reading value: 0
Thread 2 Reading value: 0
Writing value: 1
# 第二次执行结果
Thread 0 Reading value: 0
Thread 3 Reading value: 0
Thread 1 Reading value: 0
Thread 4 Reading value: 0
Thread 2 Reading value: 0
Writing value: 1

这里有一个问题，就是如果写线程最后执行，那么读线程读的都是原始数据，如果写线程先执行，那么读的就是修改后的数据，所以对读写顺序有要求的话应该做好时序的控制

名为逗比
关注
  • 26
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Rust 基础篇】Rust 多线程：并发编程的艺术
繁依Fanyi的博客
07-20 711
本篇博客详细介绍了 Rust 中多线程的使用方法，包括创建线程、线程间通信、等待线程结束等。Rust 提供了强大的多线程支持，通过合理地使用同步原语可以避免线程安全问题。希望本篇博客对你理解和应用 Rust 中的多线程编程有所帮助。
wasm-mt:用于Rust和WebAssembly的多线程库
05-05
wasm-mt | | 用于Rust和WebAssembly的多线程库。 wasm-mt帮助您创建和执行基于Web Worker的线程。 您可以简单地使用Rust闭包对线程进行编程，并使用async/await对其进行编排。 例子 wasm-mt-pool wasm-mt基于wasm-mt线程池库。 [| ] 您可以在浏览器中运行以下所有应用！ EXEC -如何使用wasm_mt 。 [| ] fib-使用嵌套线程计算斐波那契数列。 [| ] 执行程序-使用wasm_mt最小串行/并行执行wasm_mt 。 [| ] 并行-Julia设置串行/并行执行程序的基准。 [现场| 来源] arraybuffers-使用WasmMt::new_with_arraybuffers()演示。 [现场| 来源] 背景与实施 题目前面的开创性工作“多线程锈WASM”由@alexcri
Rust中如何进行并发编程？有哪些并发设计模式？
JessicaAustin的博客
04-25 665
例如，如果你的程序需要处理大量的并发任务，并且每个任务都是独立的，那么工作者线程池可能是一个不错的选择。Rust通过其强大的类型系统和内存安全性特性，提供了一定程度的保护，但开发者仍然需要谨慎处理并发代码，确保程序的正确性和稳定性。总之，Rust是一种非常适合进行并发编程的语言，它提供了丰富的工具和模式来支持并发编程的需求。最后，无论你是初学者还是经验丰富的开发者，通过不断学习和实践，你可以逐渐掌握Rust中的并发编程技巧，并将其应用于实际项目中，提高程序的性能和可扩展性。模块中的通道来实现线程间的通信。
Rust的并发编程（二） 多线程并发
鸿鹄之志
09-10 9728
文章目录Rust的并发编程（二）多线程并发创建子线程线程间通信使用通道传递数据共享内存 Rust的并发编程（二） 并发，是指在宏观意义上同一时间处理多个任务。并发的方式一般包含为三种：多进程、多线程以及最近几年刚刚火起来的协程。 多线程并发 线程（thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 创建子线程 Rust使用标准库中的thread模块创建线程： use
Rust：多线程并发编程
phthon1997的博客
08-01 1318
C/C++语言在操作系统的最底层也支持多线程，且语言本身以及其编译器不具备侦察和避免并行错误的能力，这对于开发者来说压力很大，开发者需要花费大量的精力避免发生错误。move闭包通常和threadspawn函数一起使用，它允许你使用其它线程的数据，创建线程时，把值的所有权从一个线程转移到另一个线程。可以使用join（）方法来等待线程的完成，会阻止当前线程的运行，知道handle所表示的线程的终结。线程不同于进程（process）的地方是线程是程序以内的概念，程序往往是在一个进程中执行的。...
rust多线程
xglinux的博客
09-21 342
tx,rx对应发送者和接收者，它们的类型由编译器自动推导: tx.send(1)发送了整数，因此它们分别是mpsc::Sender和mpsc::Receiver类型，需要注意，由于内部是泛型实现，一旦类型被推导确定，该通道就只能传递对应类型的值。在上面代码中，主线程和子线程是并发运行的，子线程在不停的发送消息 -> 休眠 1 秒，与此同时，主线程使用for循环阻塞的从rx迭代器中接收消息，当子线程运行完成时，发送者tx会随之被drop，此时for循环将被终止，最终main线程成功结束。
Rust语言教程.docx
04-24
Rust语言的主要特点包括： 内存安全：Rust使用所有权（ownership）系统来管理内存，这有助于避免内存泄漏和数据竞争等常见的内存安全问题。所有权系统还让开发者能在编译时进行静态检查，预防运行时可能出现的错误...
Rust语言教程简介以及优点
05-30
这确保了即使在复杂的数据结构和多线程环境下，代码仍然安全。 Rust还强调零成本抽象，这意味着可以在不牺牲运行时性能的情况下创建高级抽象。你可以编写高性能的低级代码，同时享受类似高级语言的便利。此外，Rust...
Rust 程序设计语言 简体中文版.pdf
10-28
"Rust 程序设计语言 简体中文版.pdf" 本书是 Rust 程序设计语言的简体中文译本，由 Rust 中文社区翻译。...因此，Rust 程序设计语言是一本非常实用的书籍，适合很多开发者，尤其是那些想学习 Rust 的人。
【Rust编程核心】Trait：Rust语言的契约与行为
07-04
Rust语言的设计目标是提供对内存安全和数据竞争的保证，同时保持C和C++级别的性能。 Rust的主要特点包括： 1. **内存安全**：Rust的所有权（ownership）、借用（borrowing）和生命周期（lifetimes）系统在编译时就...
Rust 语言 Rust 是一种系统编程语言，注重安全、性能和并发性 以下是 Rust 语言的一些关键特点： 内存安全 通过严
最新发布
07-14
提供了安全且高效的并发模型，使开发者能够轻松编写多线程和并发程序，而无需担心常见的并发错误。 性能高效 能与 C 和 C++ 等低级语言相媲美，同时保持高级语言的表达能力和安全性。 函数式编程风格 支持函数式编程...
Rust语言的多线程编程
跨链技术践行者
05-13 893
写这篇短文的时候，正值Rust1.0发布不久，严格来说这是一门兼具C语言的执行效率和Java的开发效率的强大语言，它的所有权机制竟然让你无法写出线程不安全的代码，它是一门可以用来写操作系统的系统级语言，如果说新一代编程语言是什么，那就Rust了。 下面我注重介绍Rust的多线程编程是怎样，其中大部分内容参考翻译自Rust的官方文档，请看： Concurrency并发 在计算机科学上，并发Concurrency 和并行parallelism是非常重要的话题，也是软件产业一个热门的话题。计算机CPU有了.
Rust学习记录 -＞ 线程Thread
weixin_45704680的博客
11-02 793
文章目录前言一、线程Thread是什么？二、使用线程进行编程1.简单的线程定义与使用2.多线程使用再探讨总结 前言 本文接上一篇rust学习记录，在对闭包进行学习后开始学习Rust中线程的使用，下文即对笔者在学习中所学到的知识及遇到的问题和思考进行记录总结. 该篇文章同样参考自视频b站令狐一冲Rust进阶 一、线程Thread是什么？ 首先在这里先介绍进程： 进程是资源分配的最小单位，而线程是CPU调度的最小单位。也就是说一个进程下会有多个线程同时存在，这些线程共同使用一套映射表。 而在使用多线程时.
Rust 多线程编程
void的博客
10-02 662
一个进程一定有一个主线程，主线程之外创建出来的线程称为子线程多线程编程，其实就是在主线程之外创建子线程，让子线程和主线程并发运行，完成各自的任务。Rust语言支持多线程编程。Rust语言标准库中的 std::thread 模块用于多线程编程。std::thread 提供很很多方法用于创建线程、管理线程和结束线程。
Rust 多线程基础
Rust语言学习交流
09-29 2161
本文来自 ahageek 同学的投搞。好久不写博客了, 忙里偷闲写一篇, 主要参考自 The Rust Programming Languagehttps://doc....
Rust语言入门教程(十五) -线程(Thread)
因吹斯汀
11-30 110
Rust的线程具有很好的可移植性，在Mac, Window, Linux以及其他许许多多不能一一列举的平台上，Rust的线程都可以完美运行。
Rust学习第十四天——多线程同时运行代码
yryryrkkx的博客
02-08 825
感觉学的东西越来越难了，不过我相信，坚持下去，总有顺手的一天。三毛在散文《简单》里写道：“我避开无事时过分热络的友谊，这使我少些负担和承担。我不多说无谓的闲言，这使我觉得清畅。我当心的去爱别人，因为比较不会泛滥。我不求深刻，只求简单。
【一起学Rust | 基础篇】rust线程与并发
广龙宇的博客
03-15 1609
并发编程（Concurrent programming），指的是程序的不同部分相互独立的执行。而并行编程（parallel programming）代表程序不同部分于同时执行，这两个概念随着计算机越来越多的利用多处理器的优势时显得愈发重要。由于历史原因，在此类编程中一直是困难且容易出错的：Rust 希望能改变这一点。
rust 多线程同步
03-25
Rust是一种现代的系统级编程语言，它提供了内存安全、并发性和高性能的特性。在Rust中，多线程同步是通过标准库中的原子类型和同步原语来实现的。 Rust的原子类型（Atomic Types）是一种特殊的数据类型，可以在多个线程之间进行原子操作，保证操作的原子性。常见的原子类型包括AtomicBool、AtomicIsize、AtomicUsize等。通过原子类型，可以实现多线程之间的共享数据的安全访问。 除了原子类型，Rust还提供了一些同步原语，用于实现多线程之间的同步和互斥。其中最常用的是Mutex和RwLock。Mutex提供了互斥锁机制，确保在同一时间只有一个线程可以访问被锁定的数据。RwLock则提供了读写锁机制，允许多个线程同时读取数据，但只允许一个线程进行写操作。 使用Rust进行多线程同步的一般步骤如下： 1. 导入所需的库：在Rust中，需要使用std::sync模块中的相关类型和函数来实现多线程同步。 2. 创建共享数据：定义需要在多个线程之间共享的数据结构。 3. 使用原子类型：对需要在多个线程之间进行原子操作的数据使用原子类型进行封装。 4. 使用同步原语：使用Mutex或RwLock对需要进行互斥访问的数据进行封装。 5. 创建线程：使用std::thread模块创建多个线程，并传递共享数据的引用给每个线程。 6. 进行同步操作：在每个线程中，使用Mutex的lock方法获取锁，并对共享数据进行操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值