rust : condvar中一对一和多对一模式初探

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()这个过程,需要特别小心,否则可能会想象中不一样。这个里面有一些操作系统线程 调度机制比较底层,是比较复杂的。

相关推荐
浮生如梦_40 分钟前
Halcon基于laws纹理特征的SVM分类
图像处理·人工智能·算法·支持向量机·计算机视觉·分类·视觉检测
XiaoLeisj2 小时前
【JavaEE初阶 — 多线程】单例模式 & 指令重排序问题
java·开发语言·java-ee
励志成为嵌入式工程师3 小时前
c语言简单编程练习9
c语言·开发语言·算法·vim
捕鲸叉3 小时前
创建线程时传递参数给线程
开发语言·c++·算法
A charmer3 小时前
【C++】vector 类深度解析:探索动态数组的奥秘
开发语言·c++·算法
Peter_chq3 小时前
【操作系统】基于环形队列的生产消费模型
linux·c语言·开发语言·c++·后端
wheeldown4 小时前
【数据结构】选择排序
数据结构·算法·排序算法
记录成长java5 小时前
ServletContext,Cookie,HttpSession的使用
java·开发语言·servlet
前端青山5 小时前
Node.js-增强 API 安全性和性能优化
开发语言·前端·javascript·性能优化·前端框架·node.js
hikktn5 小时前
如何在 Rust 中实现内存安全:与 C/C++ 的对比分析
c语言·安全·rust