Untitled

use std::fmt::Debug;
use std::sync::Arc;
use crossbeam::channel::{Receiver, Sender, unbounded};

struct Dispatcher<T: Send + Clone + 'static>{
    sender: Sender<T>,
    receiver: Receiver<T>
}

struct Subscription<T: Send + Clone + Debug + 'static>{
    receiver: Receiver<T>
}

impl<T: Send + Clone + 'static> Dispatcher<T> {
    fn new() -> Self{
        let (sender, receiver) = unbounded();
        return Dispatcher{
            sender,
            receiver
        }
    }

    fn dispatch(&self, msg: T){
        self.sender.send(msg);
    }

    fn subscribe(&self) -> Subscription<T> where T: Debug {
        return Subscription{
            receiver: self.receiver.clone()
        }
    }
}

impl <T: Send + Clone + Debug + 'static> Subscription<T>{
    fn read(&self) -> Option<T>{
        let res = self.receiver.recv().unwrap();
        return Some(res);
    }
}


fn main() {
    let mut threads = Vec::new();
    let str = Arc::new(Dispatcher::new());

    for i in 0..10{
        let strcp = str.clone();
        threads.push(std::thread::spawn(move || {
            if i%2==0 {
                strcp.dispatch(move || "prova");
            } else {
                let subscriber = strcp.subscribe();
                subscriber.read();
            }
        }))
    }
}