condvar是不经常碰到的，但其实在tokio之类库中，还是非常核心的作用。
想进一步体会condvar的使用，还是从场景出发。
一、一个通知发送者，一个接收者
假定一个员工收到一个任务，就是模拟是一个时间片，到时了，就会触发通知发出（notify_one）。
通知也有不断发出通知，还是事件触发后再发出通知。这些根据场景需要都可以。
不管形式如何，但mutex中data值的不同状态，wait判断事件是否已经发生的标志。
use std::sync::{ Arc, Condvar, Mutex };
use std::thread;
use std::time::{Duration,Instant};
use std::collections::HashMap;
fn main_single() {
let builder = thread::Builder::new();
let pair = Arc::new((Mutex::new(false), Condvar::new())); // data为bool值，以此判断事件是否发出
let pair2 = Arc::clone(&pair);
//单个通知者
let handle = builder.spawn(move || {
let start = Instant::now();
let mut num_send = 0;
let mut is_ok =false;
while !is_ok {
thread::sleep(Duration::from_secs(1));
let (lock, cvar) = &*pair2;
let mut started = lock.lock().unwrap();
num_send +=1;
println!("员工：第 {:?} 次报告；任务执行中.....，已耗时: {:?} 秒",num_send, start.elapsed().as_secs());
cvar.notify_one();
let is_event_happened = start.elapsed().as_secs() >6;
if is_event_happened{
println!("员工: 报告boss,任务已经完成了！共耗时: {:?} 秒",start.elapsed().as_secs());
*started = true;
//cvar.notify_all();
is_ok = true;
}
}
});
let mut is_received = false;
let seconds = 1;
let start = Instant::now();
let mut num_receive = 0;
while !is_received {
let (lock, cvar) = &*pair;
let mut started = lock.lock().unwrap();
started = cvar.wait(started).unwrap();
if *started == false{
println!("boss: 时间过去 {:?} 秒，任务还没完成！",start.elapsed().as_secs());
}else {
println!("boss: 好！收到员工任务完成信息！现在过去了 {:?} 秒！",start.elapsed().as_secs());
is_received = true;
}
num_receive +=1;
println!("boss: 收到! 收到{:?} 次报告，共过去了: {:?} 秒",num_receive, start.elapsed().as_secs());
thread::sleep(Duration::from_secs(seconds));
}
if is_received{
println!("任务完成！");
}else{
println!("任务失败！");
}
handle.expect("任务失败！boss要崩溃了！").join().unwrap();
}
fn main(){
main_single()
}
这种场景比较简单，是一对一的。但其它典型的场景可能还有多对一，不断发送通知给一个接收者。象N个员工和一个上级。
二、多个通知者，一个接收者
通过Mutex中包裹一个Hashmap结构，来对多个通知的状态进行管理。
下例构造了3个员工汇报对应一个老板接收的方式。
mutex中值的结构是hashmap<usize,(nums,bool)>结构，分别指的是员工id编号usize,以及此员工通知发送次数nums,以及事件是否发生标志状态bool。
这个数据结构根据自己需要来设定，这里只是一个假设了一个相对信息量复杂的场景。
use std::sync::{ Arc, Condvar, Mutex };
use std::thread;
use std::time::{Duration,Instant};
use std::collections::HashMap;
fn main_multi(){
let pair = Arc::new((Mutex::new(HashMap::new()), Condvar::new()));
let mut handles = Vec::new();
const PERSONS :usize = 3;//多个成员向1个
let each_send_seconds = 1;
for i in 0..PERSONS {
let _pair = Arc::clone(&pair);
let handle = thread::spawn(move || {
let start = Instant::now();
let mut num_send = 0;
let mut is_ok = false;
while !is_ok {
thread::sleep(Duration::from_secs(each_send_seconds));
let (lock, cvar) = &*_pair;
let mut locked = lock.lock().unwrap();
num_send +=1;
let is_event_happened = start.elapsed().as_secs() >= 6;//定义为事件
if is_event_happened{
println!("员工: 我是员工{:?} ,报告boss,我任务执行完成！共耗时: {:?} 秒",i,start.elapsed().as_secs());
(*locked).insert(i,(num_send,true));
is_ok = true;
}else{
println!("员工：我是员工{:?} ,第 {:?} 次报告，任务执行中.....，已耗时:: {:?} 秒",i,num_send, start.elapsed().as_secs());
(*locked).insert(i,(num_send,false));
}
cvar.notify_one();
}
});
handles.push(handle);
}
let mut is_all_received = false;
//let each_recv_seconds = 1;
let start = Instant::now();
//let mut num_receive = 0;
while !is_all_received {
let mut is_status = vec![false;PERSONS];
//每次轮询全部一次
let (lock, cvar) = &*pair;
let mut locked = lock.lock().unwrap();
locked = cvar.wait(locked).unwrap();
for i in 0..PERSONS{
if (*locked).contains_key(&i){
let num = (*locked).get(&i).unwrap();
let status = num.1;
if status{
println!("员工：{:?}, 通知次数: {:?} status : {:?}",i,num.0,status);
is_status[i] = true;
}
}
}
if is_status.iter().all(|&i| i == true){
println!("boss: 很好，收到全部员工任务完成的信息！现在过去了 {:?} 秒！",start.elapsed().as_secs());
is_all_received = true;
}
}
if is_all_received {
println!("任务完成！");
}else{
println!("任务失败！");
}
println!("任务总共花了: {:?} 秒", start.elapsed().as_secs());
handles.into_iter().for_each(|w| w.join().unwrap());
}
fn main(){
//main_single();
main_multi();
}
运行结果：
员工：我是员工2 ,第 1 次报告，任务执行中.....，已耗时:: 1 秒
员工：我是员工1 ,第 1 次报告，任务执行中.....，已耗时:: 1 秒
员工：我是员工0 ,第 1 次报告，任务执行中.....，已耗时:: 1 秒
员工：我是员工0 ,第 2 次报告，任务执行中.....，已耗时:: 2 秒
员工：我是员工1 ,第 2 次报告，任务执行中.....，已耗时:: 2 秒
员工：我是员工2 ,第 2 次报告，任务执行中.....，已耗时:: 2 秒
员工：我是员工1 ,第 3 次报告，任务执行中.....，已耗时:: 3 秒
员工：我是员工0 ,第 3 次报告，任务执行中.....，已耗时:: 3 秒
员工：我是员工2 ,第 3 次报告，任务执行中.....，已耗时:: 3 秒
员工：我是员工0 ,第 4 次报告，任务执行中.....，已耗时:: 4 秒
员工：我是员工1 ,第 4 次报告，任务执行中.....，已耗时:: 4 秒
员工：我是员工2 ,第 4 次报告，任务执行中.....，已耗时:: 4 秒
员工：我是员工2 ,第 5 次报告，任务执行中.....，已耗时:: 5 秒
员工：我是员工0 ,第 5 次报告，任务执行中.....，已耗时:: 5 秒
员工：我是员工1 ,第 5 次报告，任务执行中.....，已耗时:: 5 秒
员工: 我是员工2 ,报告boss,我任务执行完成！共耗时: 6 秒
员工：2, 通知次数: 6 status : true
员工: 我是员工1 ,报告boss,我任务执行完成！共耗时: 6 秒
员工: 我是员工0 ,报告boss,我任务执行完成！共耗时: 6 秒
员工：0, 通知次数: 6 status : true
员工：1, 通知次数: 6 status : true
员工：2, 通知次数: 6 status : true
boss: 很好，收到全部员工任务完成的信息！现在过去了 6 秒！
任务完成！
任务总共花了: 6 秒
三、多对多模式
在多对一的基础上，还可以衍生中多对多的模式。这个可以扩展一下。也可用到noftify_all。
四、其它相关问题
要注意notify_one()到wait()这个过程，需要特别小心，否则可能会想象中不一样。这个里面有一些操作系统线程 调度机制比较底层，是比较复杂的。