Untitled

use std::sync::mpsc::{channel, Sender};
use std::thread::JoinHandle;
use std::time::Duration;

//unsafe impl Send for Message{}

#[derive(Debug)]
struct Message {
    msg: usize
}

struct Looper {
    sender: Sender<Message>,
    threads: Vec<JoinHandle<()>>
}

impl Looper{
    fn new <T: Fn(Message)->() + Send + 'static, Q: Fn()->() + Send + 'static> (process: T, cleanup: Q) -> Self {
        let (tx, rx) = channel::<Message>();
        let mut threads = Vec::new();
        threads.push(std::thread::spawn(move || {
            while let Ok(msg) = rx.recv(){
                process(msg);
            }
            cleanup();
        }));
        return Looper{
            sender: tx,
            threads
        }
    }

    pub fn send(&self, msg: Message){
        self.sender.send(msg);
    }
}

fn main() {
    let f1 = |mut s: Message| {s.msg = 1;
        std::thread::sleep(Duration::new(1, 0));
        println!("Processata{:?}", s)};
    let f2 = || {println!("Cleanup!")};
    let str = Looper::new(f1, f2);
    let str2 = Looper::new(f1, f2);

    str.send(Message{msg: 2});
    str2.send(Message{msg: 3});

    std::mem::drop(str.sender);
    std::mem::drop(str2.sender);

    for i in str.threads{
        i.join().unwrap();
    }
}