写点什么

Rust 多线程之数据共享

用户头像
编号94530
关注
发布于: 2020 年 07 月 17 日
Rust多线程之数据共享

1. 怎么创建线程



我们都知道Java中通过实现Runnable接口或继承Thread类,来完成一个线程的创建,那么在Rust中是如何实现一个线程的呢?代码如下。



fn how_to_create_a_thread(){
// 创建一个线程
let thread_handle = thread::spawn(|| {
println!("Thread inner");
});
// 阻塞线程,并等待其自己执行完毕
thread_handle.join().unwrap();
}



在Rust中,在std::thread,可以直接通过thread::spawn(||{})方式创建出一个线程,并且返回该线程JoinHandle,可以通过JoinHandle进行join操作。



2. 如何实现线程数据共享?



2.1 单线程



不难猜出,同Java类似,通过加锁的方式保证其数据安全。我们来看具体实现代码。



fn test_single_thread(){
let m = Mutex::new(5);
{
let mut num = m.lock().unwrap();
*num = 6;
}
println!("m = {:?}", m);
}



在Rust中,通过std::sync::Mutex类,Mutex::new(t: T),将需要共享的数据放进去即可,通过,lock()方法,对数据加锁并获取数据,这样就可以对加锁的数据进行操作。 但是与Java有所不同的是:Rust中的锁实现了Drop接口,会自动释放,不需要手动Unlock。用Java代码解释,就是类似实现了AutoCloseable接口,可以实现自动关闭。代码如下:



public class Mutex implement AutoCloseable{
public void close() throws Exception{
}
}
try(Mutex mut = new Mutex(5)){
}



2.2 多线程



单线程实现数据共享看起来蛮简单的,直接创建一个线程,然后运行就完了,就看不出来。那如何实现多线程呢?代码如下:



// 多线程和锁
fn test_mulit_thread() {
// 使用Arc实现clone功能
// 对Mutex::new生成的对象实现clone功能
// 如果不实现clone,只能移动一次
let lock_sub = Arc::new(Mutex::new(0));
let mut thread_list = vec![];
for _ in 0..10 {
// clone 锁对象,否则下方 move一次后,其他for循环将获取不到锁对象
let lock = Arc::clone(&lock_sub);
let thandle = thread::spawn(move || {
let mut num = lock.lock().unwrap();
*num += 1
});
thread_list.push(thandle);
}
for handle in thread_list {
handle.join().unwrap();
}
println!("Result : {}", *lock_sub.lock().unwrap());



上方例子是标准实现多线程数据共享的方式。其实有如下疑问,可以说一下。



  1. 为什么要使用Arc对象包装?



Arc原名:atomically reference counted,原子引用计数。是Rc类型的原子扩展。包含clone方法,对对象进行clone。便于多线程操作同一个对象。



  1. 线程中move问题



move可以从字面意思理解,就是移动,把lock对象从一个作用域移动到了线程类。Rust对对象的所有权有严格控制,这个需要了解。



2.2.1 疑问



通过上面的方式实现了多线程,其实还有蛮多疑问的, 如果我就是不用Arc对象,而是采用普通对象,或者说Rc对象了,就真的不能实现多线程间的数据共享吗?



2.2.1.1 普通对象



普通对象即:直接一个对象。 这有的方式不行,因为多线程间共享变量就必须用到多个对象,即对象的多副本,那么就要实现Rc对象。



2.2.1.2 用Rc对象实现多数据共享



通过Rc对象,来实现多线程数据共享,代码如下。



fn test_mulit_thread_by_rc() {
let lock_sub = Rc::new(Mutex::new(0));
let mut thread_list = vec![];
for _ in 0..10 {
let lock = Rc::clone(&lock_sub);
let thandle = thread::spawn(move || {
let mut num = lock.lock().unwrap();
*num += 1
});
thread_list.push(thandle);
}
for handle in thread_list {
handle.join().unwrap();
}
println!("Result : {}", *lock_sub.lock().unwrap());
}



代码同Arc没什么不同,就是把Arc对象换成Rc对象,然后试着编译。出现如下错误:



45 | let thandle = thread::spawn(move || {
| _______________________^^^^^^^^^^^^^_-
| | |
| | `std::rc::Rc<std::sync::Mutex<i32>>` cannot be sent between threads safely



标红的提示:`std::rc::Rc<std::sync::Mutex<i32>> cannot be sent between threads safely`,就是说Rc不是线程安全的。没办法,编译不过去。不死心,我又换了一种写法。代码如下。



fn test_mulit_thread_by_rc() {
let lock_sub = Rc::new(0);
let mut thread_list = vec![];
for _ in 0..10 {
let mut lock = Rc::clone(&lock_sub);
let thandle = thread::spawn(move || {
*lock += 1
});
thread_list.push(thandle);
}
for handle in thread_list {
handle.join().unwrap();
}
println!("Result : {}", *lock_sub);
}



我放弃锁了,不加锁,能行吗? 通过编入后,还是出现了 std::rc::Rc<std::sync::Mutex<i32>> cannot be sent between threads safely`这个错误,看来和Mutex对象没有关系啦。



3. 总结



本文主要讲述了如何实现线程,多线程,以及线程间的数据共享问题。但是我们知道,在多线程中,多线程操作数据,会出现死锁等问题,这个还没有说道。以后在慢慢聊。希望本文对大家有所帮助。谢谢!



发布于: 2020 年 07 月 17 日阅读数: 57
用户头像

编号94530

关注

你的每一个点赞我都当成了喜欢 2020.04.29 加入

公众号: 星球x 欢迎大家关注,谢谢!

评论

发布
暂无评论
Rust多线程之数据共享