rust学习-线程

~kiss~2023-07-26 11:00

Rust 标准库只提供了 1:1 线程模型

Rust 是较为底层的语言，如果愿意牺牲性能来换取抽象，以获得对线程运行更精细的控制及更低的上下文切换成本，使用实现了 M:N 线程模型的 crate

示例

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

fn main() {
    // 调用 thread::spawn 函数并传递一个闭包，来创建线程
    let handle = thread::spawn(|| {
        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));
    }

    // 等待结束
    // // `unwrap` 在接收到 `None` 时将返回 `panic`
    handle.join().unwrap();
}

在一个线程中使用另一个线程的数据

在参数列表前使用 move 关键字强制闭包获取其使用的环境值的所有权。

这个技巧在创建新线程将值的所有权从一个线程移动到另一个线程时最为实用

use std::thread;

fn main() {
    let v = vec![1, 2, 3]
    
    let handle = thread::spawn(|| {
        // `v` is borrowed here
        // Rust 不知道这个新建线程会执行多久，所以无法知晓 v 的引用是否一直有效
        println!("Here's a vector: {:?}", v);
    });

	// 一个具有闭包的线程，尝试使用一个在主线程中被回收的引用 v
	// drop(v);

    handle.join().unwrap();
}

force the closure to take ownership of v (and any other referenced variables), use the move keyword

use std::thread;

fn main() {
    let v = vec![1, 2, 3];

    // 增加 move 关键字，强制闭包获取其使用的值的所有权
    let handle = thread::spawn(move || {
        println!("Here's a vector: {:?}", v);
    });

    handle.join().unwrap();
    // value borrowed here after move
    println!("Here's a vector: {:?}", v); // 这里编译报错
}

use std::thread;

fn main() {
    let v = vec![1, 2, 3]
    
    let handle = thread::spawn(move || {
        // `v` is borrowed here
        println!("Here's a vector: {:?}", v);
    });

    handle.join().unwrap();
}

channel

mpsc：multiple producer, single consumer

基本用法

use std::thread;
// 多发单收模型
// multiple producer, single consumer
use std::sync::mpsc;

fn main() {
	// tx 是发送端，rx是接收端
    let (tx, rx) = mpsc::channel();

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

	// 主线程阻塞
    let received = rx.recv().unwrap();
    println!("Got: {}", received);
}

try_recv 不会阻塞，相反它立刻返回一个 Result<T, E>：Ok 值包含可用的信息，而 Err 值代表此时没有任何消息

示例

use std::thread;
use std::sync::mpsc;
use std::time::Duration;

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

    thread::spawn(move || {
        let vals = vec![
            String::from("hi"),
            String::from("from"),
            String::from("the"),
            String::from("thread"),
        ];

        for val in vals {
            tx.send(val).unwrap();
            thread::sleep(Duration::from_secs(1));
        }
    });

	// 打印出四个消息后退出
    for received in rx {
        println!("Got: {}", received);
    }
}

所有权被转移

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

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

    thread::spawn(move || {
        let val = String::from("hi");
        tx.send(val).unwrap();
        // 编译失败
        //  value borrowed here after move
        println!("val is {}", val);
    });

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

多生产者

通过克隆通道的发送端来做到

类似于Go中的："不要通过共享内存来通讯；而是通过通讯来共享内存

（"Do not communicate by sharing memory; instead, share memory by communicating."）

use std::thread;
use std::sync::mpsc;
use std::time::Duration;

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

    let tx1 = tx.clone();
    thread::spawn(move || {
	let vals = vec![
	    String::from("hi"),
	    String::from("from"),
	    String::from("the"),
	    String::from("thread"),
	];

	for val in vals {
	    tx1.send(val).unwrap();
	    thread::sleep(Duration::from_secs(1));
	}
    });

    thread::spawn(move || {
	let vals = vec![
	    String::from("more"),
	    String::from("messages"),
	    String::from("for"),
	    String::from("you"),
	];

	for val in vals {
	    tx.send(val).unwrap();
	    thread::sleep(Duration::from_secs(1));
	}
    });

    for received in rx {
	println!("Got: {}", received);
    }

    println!("finish")
}

Mutex 互斥器

使用方式

cat main.rs
use std::sync::Mutex;

fn main() {
    let m = Mutex::new(5);

    {
        // lock 调用 返回 一个叫做 MutexGuard 的智能指针
        // 这个智能指针实现了 Deref 来指向其内部数据
        // 也提供了一个 Drop 实现当 MutexGuard 离开作用域时自动释放锁
        let mut num = m.lock().unwrap();
        *num = 6;
    }

    // 打印内容如下 Mutex { data: 6, poisoned: false, .. }
    println!("m = {:?}", m);
}

糟糕例子

use std::sync::Mutex;
use std::thread;

fn main() {
    let counter = Mutex::new(0);
    let mut handles = vec![];

    for _ in 0..10 {
        // value moved into closure here, in previous iteration of loop
        // 编译失败
        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

Arc 和 Rc 有着相同的 API

Arc 一个类似 Rc 并可以安全的用于并发环境的类型

字母 "a" 代表 原子性（atomic），所以这是一个原子引用计数

为什么不是所有标准库中的类型都默认使用 Arc 实现？

线程安全带有性能惩罚，只在必要时才为此买单

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

fn main() {
    // counter 是不可变的，因为前面没有mut
    // 意味着Mutex<T> 提供了内部可变性
    // 就像使用 RefCell<T> 可以改变 Rc<T> 中的内容那样
    // 使用 Mutex<T> 来改变 Arc<T> 中的内容 
    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();
    }

	// 打印结果为10
    println!("Result: {}", *counter.lock().unwrap());
}

Mutex 也有造成 死锁（deadlock） 的风险

使用 Sync 和 Send trait 的可扩展并发

语言本身对并发知之甚少。上述讨论的几乎所有内容都属于标准库，而不是语言本身的内容，可以编写自己的或使用别人编写的并发功能。

但有两个并发概念是内嵌于语言中的：std::marker 中的 Sync 和 Send trait

通过 Send 允许在线程间转移所有权

【Send 标记 trait】

表明类型的所有权可以在线程间传递

几乎所有的 Rust 类型都是Send 的，但是也有例外，比如Rc

如果克隆了 Rc 的值并尝试将克隆的所有权转移到另一个线程，这两个线程都可能同时更新引用计数，Rc 被实现为用于单线程场景，所以不用担心多线程下的引用计数问题。

糟糕例子

the trait Send is not implemented for Rc<Mutex<i32>>

use std::rc::Rc;
use std::sync::Mutex;
use std::thread;

fn main() {
    let counter = Rc::new(Mutex::new(0));
    let mut handles = vec![];

    // Rc<Mutex<i32>>` cannot be sent between threads safely
    for _ in 0..10 {
        let counter = Rc::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

Sync 允许多线程访问

【Sync 标记 trait】

一个实现了 Sync 的类型可以安全的在多个线程中拥有其值的引用

对于任意类型 T，如果 &T（T 的引用）是 Send 的话 T 就是 Sync 的

其引用就可以安全的发送到另一个线程

Rc 不是 Sync的

RefCell 和 Cell 系列类型不是 Sync 的

RefCell 在运行时所进行的借用检查也不是线程安全的

Mutex 是 Sync 的，可以被用来在多线程中共享访问

相关推荐
scc214010 分钟前
spark的学习-06
javascript·学习·spark
luoganttcc10 分钟前
能否推荐开源GPU供学习GPU架构
学习·开源
材料苦逼不会梦到计算机白富美24 分钟前
线性DP 区间DP C++
开发语言·c++·动态规划
java小吕布25 分钟前
Java Lambda表达式详解：函数式编程的简洁之道
java·开发语言
sukalot29 分钟前
windows C#-查询表达式基础(一)
开发语言·c#
垂杨有暮鸦⊙_⊙35 分钟前
阅读2020-2023年《国外军用无人机装备技术发展综述》笔记_技术趋势
笔记·学习·无人机
一二小选手1 小时前
【Java Web】分页查询
java·开发语言
大G哥1 小时前
python 数据类型----可变数据类型
linux·服务器·开发语言·前端·python
Code成立1 小时前
《Java核心技术 卷I》用户图形界面鼠标事件
java·开发语言·计算机外设
Mephisto.java1 小时前
【大数据学习 | HBASE高级】region split机制和策略
数据库·学习·hbase
热门推荐
01玄机平台应急响应—webshell查杀02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04智能车联网安全发展形势、挑战05文件或文件夹名称中有空格如何批量去除06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07【TC3xx芯片】TC3xx芯片电源管理系统PMS详解08优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10液体神经网络：LNN是个啥概念？