Rust并发控制之Condvar-两线程交替打印

在并发控制的面试里有个很喜欢考的点：如何控制两个并发线程交替打印 1 和 2。

考察的是如何做并发线程的同步控制，实现的方式有很多，今天我们先用上篇提到的 condvar 试试。

思路是利用条件变量来控制两个线程：

• 线程 1：当且仅当条件为 false 时开始打印 1，并修改条件为 true, 通知等待的另一个线程打印 2，否则 while 阻塞等待
• 线程 2：条件为 false 时阻塞等待 notify，直到条件为 true，然后重置条件为 false，并打印 2

代码及注释如下：

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

fn main() {
    let pair = Arc::new((Mutex::new(false), Condvar::new()));
    let cnt = 3;
    let pair2 = pair.clone();

    let t1 = thread::spawn(move || {
        let &(ref lock, ref cvar) = &*pair2;
        for _ in 0..cnt {
            while let Ok(mut v) = lock.lock() {
                // 条件为false时开始打印1
                // 并修改条件为true, 通知等待的另一个线程打印2
                if !*v {
                    print!("1 ");
                    *v = true;
                    cvar.notify_one();
                    break;
                } else {
                    // 及时释放锁，不让mutexguard被scope结束时才释放
                    // 如果后续没操作的话，可以不用这里drop，等离开scope时自动释放也一样
                    drop(v);
                    // [2]
                    // std::thread::sleep(std::time::Duration::from_millis(1));
                    // [1]
                    // print!(" waitting... ");
                }
            }
        }
    });
    let t2 = thread::spawn(move || {
        for _ in 0..cnt {
            let &(ref lock, ref cvar) = &*pair;
            let mut v = lock.lock().unwrap();
            // 条件为false时等待notify，直到条件为true
            while !*v {
                v = cvar.wait(v).unwrap();
            }
            // 重置条件为false，并打印2
            *v = false;
            print!("2 ");
        }
    });
    t1.join().unwrap();
    t2.join().unwrap();
}

运行结果可以实现打印 1 2 1 2 1 2

不过线程 1 用遍历阻塞其实还是消耗了不少 cpu 时间，恢复注释[1]的打印可以看出，又多次 waitting 输出

可以加一点等待 sleep 让出cpu占用，如注释[2]来减少频繁对锁的抢占。