Rust多线程交叉打印

Rust多线程交叉打印+Send Sync特征讲解

一、Rust多线程交叉打印

• 先说背景
• 有两个线程，分别为0号线程和1号线线程
• 两个线程交叉打印共享值，并将共享值+1
• 当标志为false时，0号线程打印，标志为true时，1号线程打印
• 要求0号线程先打印

我们看代码

use std::sync::{Arc, Condvar, Mutex};
use std::thread;
static mut count: usize = 0;//全局变量
fn main() {
    //互斥锁，每次只让一个线程负责打印
    let mutex = Arc::new(Mutex::new(false));//初始值为false
    //信号量，实现线程同步，即控制线程运行顺序
    let condvar = Arc::new(Condvar::new());
    //让主线程等子线程执行完再推出
    let mut handles = vec![];

    for i in 0..=1 {
        //两个线程都应该持有同一个锁的所有权
        let cmutex = Arc::clone(&mutex);
         //两个线程都应该持有的事同一个信号量的所有权
        let ccondavar = Arc::clone(&condvar);
        let handle = thread::spawn(move || {
            //上锁，这个锁可能是0号线程先获得，也有可能是1号线程,这段代码要求0号线程先打印，所以我们下面通过信号量来实现
            let mut lock = cmutex.lock().unwrap();
            //print!("{}", *lock);
            for j in 0..=2 {
                if i % 2 == 0 {
                    if *lock {//当mutex持有的值为false时才轮到0号线程打印，否则等待
                        lock = ccondavar.wait(lock).unwrap();
                    }
                    *lock = true;//lock为false,0号线程可以打印一次，然后设置为true是为了防止0号线程一直打印
                    unsafe {//
                        count += 1;
                        println!("{} thread ouput : {}", i, count);
                    }
                    ccondavar.notify_one();//通知1号线程可以行动了
                } else {
                    if !*lock {//当mutex持有的值为true时才轮到1号线程打印，否则释放lock，然后等待
                        lock = ccondavar.wait(lock).unwrap();
                    }
                    *lock = false;//lock为true时,0号线程可以打印一次，然后这里设置为false是为了防止0号线程一直打印
                    unsafe {
                        count += 1;
                        println!("{} thread ouput : {}", i, count);
                    }
                    ccondavar.notify_one();//通知0号线程可以行动了
                }
            }
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

   
}

运行一下

0 thread ouput : 1
1 thread ouput : 2
0 thread ouput : 3
1 thread ouput : 4
0 thread ouput : 5
1 thread ouput : 6

• 可以看到我们已经实现了交叉打印，其实我们可以假想一下，如果一开始1号线程先抢到了Mutex，1号线程会先打印吗？
• 答案是不会的，因为我们通过设置mutex的值为false，并在1号线程逻辑中的代码控制了，代码如下

if !*lock {//当mutex持有的值为true时才轮到1号线程打印，否则释放lock，然后等待
     lock = ccondavar.wait(lock).unwrap();
 }

• 可以看到如果lock的初始值为false，信号量通过wait函数释放了这个锁，所以哪怕1号线程在最开始抢到了锁，也会在这里释放掉，让0号线程先打印

二、Send Sync 特征讲解

在Rust中，有一个很重要的机制就是所有权机制，值的赋值行为，很有可能导致一个值移动来移动去，使得在Rust的多线程编程中变得很难管理。

于此同时，多线程编程中，多个线程使用(拥有一个所有权)同一个变量的场景也是非常常见的，因为Rust提出了一个Rc和Arc。

Rc和Arc一个共同特征:

• 能够让一个值能有多个拥有者，即一个值，产生了多个所有权

但是Rc和Arc一个重要的区别:

• Arc能够在多线程中，安全的移动所有权，换句话说，让一个值的所有权可以移动到另一个线程中，这是因为Arc本身实现了Send特征，我们来看一下Send特征的定义

实现Send的类型可以在线程间安全的传递其所有权

unsafe impl<T: ?Sized + Sync + Send> Send for Arc<T> {}
unsafe impl<T: ?Sized + Sync + Send> Sync for Arc<T> {}

第一部分代码中，可以看到我们需要实现线程的交叉打印，那必然线程之间是要共享一个锁，那么为了锁能够共享，那么我们需要对锁产生多个所有权，并且能够在线程之间移动所有权，所以第一份的代码中是这样：

let mutex = Arc::new(Mutex::new(false));//初始值为false

复制所有权和移动锁所有权的代码

 let cmutex = Arc::clone(&mutex);//复制所有权

 let ccondavar = Arc::clone(&condvar);
        let handle = thread::spawn(move || {//move移动所有权
            let mut lock = cmutex.lock().unwrap();

因此，多个线程，通过Arc，持有了同一个Mutex的所有权，并且是每个线程都有一个所有权，可以共享使用Mutex

那么能够安全的传递Mutex的所有权，能不能安全使用一个锁，是另一个特征Sync实现的，我们虽然安全的在多线程间移动所有权，但是能不能安全使用，还是需要实现Sync特征，所以Mutex本身实现了Sync特征。也看一下Sync特征的定义。

• 实现Sync的类型可以在线程间安全的共享(通过引用)

unsafe impl<T: ?Sized + Send> Sync for Mutex<T> {}

然后又可以看到，Mutex中，仅仅限制了其指向的值T只需要实现Send特征，这是因为锁的值，我们其实是想让线程每次单独的访问，所以在一个时刻，只有一个线程访问即可，所有T只需要Send，让一个时刻只有一个线程通过锁拿到值的一个所有权。

欢迎大家关注我的博客