Rust模块std::thread

2024-09-05 08:36
文章标签 rust 模块 std thread

本文主要是介绍Rust模块std::thread,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

【图书介绍】《Rust编程与项目实战》-CSDN博客

《Rust编程与项目实战》(朱文伟,李建英)【摘要 书评 试读】- 京东图书 (jd.com)

Rust到底值不值得学,之一  -CSDN博客

Rust到底值不值得学,之二-CSDN博客

Rust多线程编程概述-CSDN博客

12.3.2  等待所有线程完成

在前面的实例中,主线程没等到派生线程执行完毕就结束了,从而整个进程就会结束。那么怎么让派生线程执行完毕呢?答案是通过joinHandle结构体来等待所有线程完成。要了解派生线程何时完成,有必要捕获thread::spawn函数返回的JoinHandle,该结构体声明如下:

pub struct JoinHandle<T>(_);

该结构体通常由thread::spawn函数返回,或者由thread::Builder::spawn函数返回。JoinHandle在关联线程被丢弃时分离该线程,这意味着该线程不再有任何句柄,也无法对其进行连接。由于平台限制,无法克隆此句柄:加入线程的能力是唯一拥有的权限。

该结构体提供了一个函数join,允许调用方(比如主线程)等待派生线程(比如子线程)完成,该函数声明如下:

pub fn join(self) -> Result<T>

该函数等待相关线程完成。如果相关线程已经完成,则函数将立即返回。就原子内存排序而言,相关线程的完成与此函数返回同步。换句话说,该线程执行的所有操作都发生在 join 返回之后发生的所有操作之前。join的返回值通常是子线程执行的结果。

join函数的用法如下:

use std::thread;let thread_join_handle = thread::spawn(|| {//子线程执行的代码});//主线程执行的代码let res = thread_join_handle.join();      //等待子线程结束

thread_join_handle存放joinHandle结构,然后调用join方法,可以等待对应的线程执行完成。调用handle的join方法会阻止当前运行线程的执行,直到handle所表示的这些线程终结join方法返回一个线程结果值,如果线程崩溃,则返回错误码,否则返回Ok。

res将得到子线程执行的结果,我们甚至可以在创建线程时,在子线程执行的代码处直接放一个数值或字符串,从而让res得到这个数值或字符串。

如果希望join调用失败时报错一下,可以这样:

thread_join_handle.join().expect("Couldn't join on the associated thread"); //若有问题就会有提示

下面先看一个简单的实例,得到子线程的结果,相当于实现了子线程传递一个值给主线程。

【例12.2】  子线程传递值给主线程

   打开VS Code,单击菜单Terminal→New Termanal,执行命令cargo new myrust来新建一个Rust工程,工程名是myrust。在main.rs中,添加代码如下:

use std::thread;fn main() {let other_thread = thread::spawn(|| {"hello" 		 //这里就写了一个字符串,相当于子线程的执行结果就是字符串"hello"});let  res = other_thread.join().unwrap();		 //得到子线程执行结果,即"hello"println!("{}",res); 
}

保存文件并运行,运行结果如下:

hello

如果有兴趣,还可以把"hello"改为一个整数,那么res就得到这个整数值。我们甚至可以把一个函数返回值作为子线程结果传递给主线程,下面来看一个实例。

【例12.3】  把函数返回值传递给主线程

   打开VS Code,单击菜单Terminal→New Termanal,执行命令cargo new myrust来新建一个Rust工程,工程名是myrust。在main.rs中,添加代码如下:

use std::thread;
fn thfunc(n: u32) -> u32 { 			//这个函数是线程函数,后面会讲到return n+1;
}
fn main() {let child = thread::spawn(|| {let f = thfunc(30); 			//调用线程函数f   							//返回子线程结果,这里也就是函数thfunc的返回值});let res = child.join().expect("Could not join child thread");println!("{}",res);
}

函数thfunc把参数n加1后再返回,并存于f中,然后把f作为子线程的结果,这样主线程通过join函数就可以得到f的值,也就是函数thfunc的返回值。

 保存文件并运行,运行结果如下:

31

下面再看一个稍复杂点的实例,加一些循环打印。

【例12.4】  等待子线程执行完毕

  打开VS Code,单击菜单Terminal→New Termanal,执行命令cargo new myrust来新建一个Rust工程,工程名是myrust。

 在main.rs中,添加代码如下:

use std::thread;
use std::time::Duration;fn main() {let handle = thread::spawn(|| {  		//返回一个 JoinHandle 类型的值for i in 1..10 {println!("hi number {} from the spawned thread!", i);thread::sleep(Duration::from_millis(1));}});for i in 1..5 {println!("hi number {} from the main thread!", i);thread::sleep(Duration::from_millis(1));}handle.join().unwrap(); 		//阻止当前线程(主线程)执行,并等待子线程执行完毕
}

thread::spawn返回一个JoinHandle类型的值,可以将它存放到变量中。这个类型相当于子线程的句柄,用于连接线程。如果忽略它,就没有办法等待线程。在主线程main函数的结尾,我们调用了join方法来等待子线程执行完毕,即调用handle的join方法会阻止当前运行线程的执行,直到handle所表示的这些线程终结。unwrap 是一个方法,它用于从Option或Result类型中提取值。

  保存文件并运行,运行结果如下:

hi number 1 from the main thread!
hi number 2 from the main thread!
hi number 1 from the spawned thread!
hi number 2 from the spawned thread!
hi number 3 from the main thread!
hi number 4 from the main thread!
hi number 3 from the spawned thread!
hi number 4 from the spawned thread!
hi number 5 from the spawned thread!
hi number 6 from the spawned thread!
hi number 7 from the spawned thread!
hi number 8 from the spawned thread!
hi number 9 from the spawned thread!

可以看到,子线程中的for循环全部执行完毕了。

不和主线程交互的子线程是非常少见的。Rust语言和其他语言不一样的地方是,如果线程中直接使用了其他线程定义的数据,则会报错。这里所说的外部变量就是其他线程中定义的变量。比如下面的代码,子线程中直接使用主线程定义的字符串就会报错:

use std::thread;fn main() {let data = String::from("hello world");let thread = std::thread::spawn(||{println!("{}", data);});thread.join();
}

如果编译就会报错:

error[E0373]: closure may outlive the current function, but it borrows `data`, which is owned by the current function

线程中使用了其他线程的变量是不合法的,必须使用move表明线程拥有data的所有权,我们可以使用move关键字把data的所有权转到子线程内,代码如下:

use std::thread;
fn main() {let data = String::from("hello world");let thread = std::thread::spawn(move ||{	//使用move 把data的所有权转到线程内println!("{}", data);});thread.join();
}

这个时候,就能正确输出结果“hello world”了。

move闭包通常和thread::spawn函数一起使用,它允许用户使用其他线程的数据,这样在创建新线程时,可以把其他线程中的变量的所有权从一个线程转移到另一个线程,然后就可以使用该变量了。下面来看一个实例,一个常见的应用模式是使用多线程访问列表中的元素来执行某些运算。

【例12.5】  多个子线程使用主线程中的数据

  打开VS Code,单击菜单Terminal→New Termanal,执行命令cargo new myrust来新建一个Rust工程,工程名是myrust。

  在main.rs中,添加代码如下:

use std::thread;fn main() {let v = vec![1, 3, 5, 7, 9];let mut childs = vec![];for n in v {let c = thread::spawn(move || {println!("{}", n * n);});childs.push(c);};for c in childs {   				//等待所有子线程结束c.join().unwrap();}
}

这里的move是必要的,否则没法保证主线程中的v会不会在子线程结束之前被销毁。使用move之后,所有权转移到了子线程内,从而使得不会出现因为生命周期造成的数据无效的情况。子线程的执行周期可能比主线程还长。因此,很可能出现结果还没有完全打印出来,就已经结束的情况。为了防止这个情况,我们存下每个线程句柄,并在最后使用 join 阻塞主线程。

  保存文件并运行,运行结果如下:

1
9
25
49
81

12.3.4  线程函数

现在我们知道了,thread::spawn 函数接受一个闭包作为参数,闭包中的代码会在子线程中执行,比如:

let handle = thread::spawn(|| {//子线程执行的代码});

但如果子线程执行的代码比较长,我们通过会另外写一个函数来封装这些代码,这样在thread::spawn中只需写一个函数调用即可,这个在新线程中执行的函数通常称为线程函数。下面来看一个实例,我们设计了一个线程函数,并且它是一个递归函数,为了模拟长时间运行。

【例12.6】  使用一个递归的线程函数

  打开VS Code,单击菜单Terminal→New Termanal,执行命令cargo new myrust来新建一个Rust工程,工程名是myrust。

  在main.rs中,添加代码如下:

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() {let child = thread::spawn(|| {let f = fibonacci(30); 							//调用线程函数println!("Hello from a thread!. fibonacci(30) = {}", f);  	//打印数列结果f   						//返回子线程结果,这里也就是函数fibonacci的返回值});println!("Hello, world!"); 	//主线程中执行的代码let v = child.join().expect("Could not join child thread"); //等待子线程结束,并得到子线程结果println!("value: {:?}", v); 
}

我们把子线程中要执行的代码(这里是求斐波那契数列)单独放在一个函数fibonacci中,这样在thread::spawn函数中只需要调用该函数(fibonacci(30);)即可,这样代码简洁多了,而且方便模块化开发,比如可以让算法工程师专门实现斐波那契数列函数,而其他程序员只需要调用即可,这样可以做到并行开发,提高了效率。斐波那契数列函数执行时间较长,主线程末尾一定要等待子线程结束,也就是调用join函数,join返回一个Result,可以使用 expect 方法来获取返回值。这样主线程就会等待子线程完成,而不会先结束程序,这样就可以看到我们想要的结果。

  保存文件并运行,运行结果如下:

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

12.3.5  available_parallelism返回默认并行度

available_parallelism函数返回程序应使用的默认并行度的估计值。该函数声明如下:

pub fn available_parallelism() -> Result<NonZeroUsize>

并行性是一种资源,一台给定的机器提供了一定的并行能力,即它可以同时执行的计算数量的限制。这个数字通常对应CPU或计算机的数量,但在各种情况下可能会有所不同。诸如VM或容器编排器之类的主机环境可能希望限制其中的程序可用的并行量。这样做通常是为了限制(无意中)resource-intensive程序对同一台机器上运行的其他程序的潜在影响。

提供此函数的目的是提供一种简单且可移植的方式来查询程序应使用的默认并行度。它不公开有关NUMA区域的信息,不考虑(协)处理器能力的差异,并且不会修改程序的全局状态以更准确地查询可用并行度的数量。资源限制可以在程序运行期间更改,因此不会缓存该值,而是在每次调用此函数时重新计算,不应从热代码中调用它。

此函数返回的值应被视为在任何给定时间可用的实际并行量的简化近似值。要更详细或更准确地了解程序可用的并行量,用户可能还希望使用特定平台的API。以下平台限制当前适用于available_parallelism。

(1)在Windows上:它可能低估了具有超过64个逻辑CPU的系统上可用的并行量。但是,程序通常需要特定的支持才能利用超过64个逻辑CPU,并且在没有此类支持的情况下,此函数返回的数字准确地反映了程序默认可以使用的逻辑CPU的数量。它可能会高估受process-wide关联掩码或作业对象限制的系统上可用的并行量。

(2)在Linux上:当受process-wide关联掩码限制或受cgroup限制影响时,它可能会高估可用的并行量。

在具有CPU使用限制的VM(例如过度使用的主机)中运行时,可能会高估可用的并行量。此函数将在以下情况下(但不限于)返回错误:如果目标平台的并行量未知,或者程序没有权限查询可用的并行量。

【例12.7】  得到当前系统的默认并行度

   打开VS Code,单击菜单Terminal→New Termanal,执行命令cargo new myrust来新建一个Rust工程,工程名是myrust。

  在main.rs中,添加代码如下:

use std::{io, thread};fn main() -> io::Result<()> {let count = thread::available_parallelism()?.get();assert!(count >= 1_usize);println!("{},{}",count,1_usize);Ok(())}

1_usize的值就是1。我们把得到的默认并行度存于count中,如果count小于1,那就抛出异常,否则打印结果。

  保存文件并运行,运行结果如下:

2,1

可见,当前系统的默认并行度是2。

当前线程的属性包括线程id、名称。获取它们的函数被定义在std::thread:: Thread这个结构体中,所以我们首先要获取这个结构体,也就是获取当前线程的Thread结构体,这个函数是current,声明如下:

pub fn current() -> Thread

Thread其实是std::thread的一个私有结构(Struct),这个结构体对外提供了一些函数,以此来获取线程的id、名称等属性。

有了当前线程的Thread结构,就可以得到名称,该函数声明如下:

pub fn name(&self) -> Option<&str>

该函数返回字符串。

【例12.8】  获取和设置线程名称

   打开VS Code,单击菜单Terminal→New Termanal,执行命令cargo new myrust来新建一个Rust工程,工程名是myrust。在main.rs中,添加代码如下:

use std::thread;​​​​​​​fn main() {let thr0 = thread::current();                      //获取当前线程的Thread结构let thread_name = thr0.name().unwrap_or("unknown");    //获取当前线程的名称println!("当前线程的名称:{}", thread_name);             //打印输出名称}

unwrap_or是用于从Result对象中获取值的宏。当Result对象是Ok时,两者都会返回Ok中的值。但是当Result对象是Err时,unwrap_or将返回一个默认值。这个默认值是宏的参数,在调用unwrap_or时就已经确定了。所以,当你想要在Result对象是Err时使用固定的默认值时,就可以使用unwrap_or。

  保存文件并运行,运行结果如下:

当前线程的名称:main

下面再看获得当前线程的id,线程id用于区分不同的线程,id号是唯一的。在Rust中,获得当前线程id的函数声明如下:

pub fn id(&self) -> ThreadId

该函数的返回值是一个结构体ThreadId,该结构体的大小是8字节。ThreadId是一个不透明的对象,它唯一地标识在进程生存期内创建的每个线程。线程ID保证不会被重用,即使在线程终止时也是如此。ThreadId受Rust的标准库控制,ThreadId和底层平台的线程标识符概念之间可能没有任何关系。因此,这两个概念不能互换使用。ThreadId可以从结构体Thread上的id函数中得到结果。

【例12.9】  得到线程id

  打开VS Code,单击菜单Terminal→New Termanal,执行命令cargo new myrust来新建一个Rust工程,工程名是myrust。在main.rs中,添加代码如下:

use std::thread;fn main() {let child_thread = thread::spawn(|| {          //创建线程thread::current().id()        //在子线程中执行的代码得到的就是当前子线程的id});             let child_thread_id = child_thread.join().unwrap();//得到子线程的idassert!(thread::current().id() != child_thread_id);//如果表达式为假,则触发断言println!("thread::current().id()={:?},child_thread_id={:?}", thread::current().id(),child_thread_id);}

在代码中,我们不仅得到了当前线程id,还创建了另一个线程,并且比较了这两个线程id。assert!宏用于检查一个表达式是否为真(true),如果表达式为假(false),则会触发断言,程序会终止运行。

  保存文件并运行,运行结果如下:

thread::current().id()=ThreadId(1),child_thread_id=ThreadId(2)

可见,主线程和子线程的id不一样。

这篇关于Rust模块std::thread的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1138457

相关文章

python: 多模块(.py)中全局变量的导入

文章目录 global关键字可变类型和不可变类型数据的内存地址单模块(单个py文件)的全局变量示例总结 多模块(多个py文件)的全局变量from x import x导入全局变量示例 import x导入全局变量示例 总结 global关键字 global 的作用范围是模块(.py)级别: 当你在一个模块(文件)中使用 global 声明变量时,这个变量只在该模块的全局命名空

深入探索协同过滤:从原理到推荐模块案例

文章目录 前言一、协同过滤1. 基于用户的协同过滤(UserCF)2. 基于物品的协同过滤(ItemCF)3. 相似度计算方法 二、相似度计算方法1. 欧氏距离2. 皮尔逊相关系数3. 杰卡德相似系数4. 余弦相似度 三、推荐模块案例1.基于文章的协同过滤推荐功能2.基于用户的协同过滤推荐功能 前言     在信息过载的时代,推荐系统成为连接用户与内容的桥梁。本文聚焦于

Thread如何划分为Warp?

1 .Thread如何划分为Warp? https://jielahou.com/code/cuda/thread-to-warp.html  Thread Index和Thread ID之间有什么关系呢?(线程架构参考这里:CUDA C++ Programming Guide (nvidia.com)open in new window) 1维的Thread Index,其Thread

【Rust练习】12.枚举

练习题来自:https://practice-zh.course.rs/compound-types/enum.html 1 // 修复错误enum Number {Zero,One,Two,}enum Number1 {Zero = 0,One,Two,}// C语言风格的枚举定义enum Number2 {Zero = 0.0,One = 1.0,Two = 2.0,}fn m

Jenkins构建Maven聚合工程,指定构建子模块

一、设置单独编译构建子模块 配置: 1、Root POM指向父pom.xml 2、Goals and options指定构建模块的参数: mvn -pl project1/project1-son -am clean package 单独构建project1-son项目以及它所依赖的其它项目。 说明: mvn clean package -pl 父级模块名/子模块名 -am参数

寻迹模块TCRT5000的应用原理和功能实现(基于STM32)

目录 概述 1 认识TCRT5000 1.1 模块介绍 1.2 电气特性 2 系统应用 2.1 系统架构 2.2 STM32Cube创建工程 3 功能实现 3.1 代码实现 3.2 源代码文件 4 功能测试 4.1 检测黑线状态 4.2 未检测黑线状态 概述 本文主要介绍TCRT5000模块的使用原理,包括该模块的硬件实现方式,电路实现原理,还使用STM32类

linux中使用rust语言在不同进程之间通信

第一种:使用mmap映射相同文件 fn main() {let pid = std::process::id();println!(

第二十四章 rust中的运算符重载

注意 本系列文章已升级、转移至我的自建站点中,本章原文为:rust中的运算符重载 目录 注意一、前言二、基本使用三、常用运算符四、通用约束 一、前言 C/C++中有运算符重载这一概念,它的目的是让即使含不相干的内容也能通过我们自定义的方法进行运算符操作运算。 比如字符串本身是不能相加的,但由于C++中的String重载了运算符+,所以我们就可以将两个字符串进行相加、但实际

python内置模块datetime.time类详细介绍

​​​​​​​Python的datetime模块是一个强大的日期和时间处理库,它提供了多个类来处理日期和时间。主要包括几个功能类datetime.date、datetime.time、datetime.datetime、datetime.timedelta,datetime.timezone等。 ----------动动小手,非常感谢各位的点赞收藏和关注。----------- 使用datet

C8T6超绝模块--EXTI

C8T6超绝模块–EXTI 大纲 控制流程结构体分析EXTI实现按键 具体案例 控制流程 这里是流程框图,具体可以去看我STM32专栏的EXTI的具体分析 结构体分析 typedef struct {uint32_t EXTI_Line; // 中断/事件线EXTIMode_TypeDef EXTI_Mode; // EXTI 模式EXTITrigger_TypeDef EXTI_