Rust多线程之数据共享

亦凉 2022-09-07 12:24 259阅读 0赞

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。便于多线程操作同一个对象。
2.  线程中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>`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. 总结

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