Untitled

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

struct SingleThreadExecutor<T: Send + 'static> {
    sender: Mutex<Sender<T>>,
    joinhandle: JoinHandle<()>,
    close: Mutex<bool>,
}

impl<T: Send + 'static + Fn()->()> SingleThreadExecutor<T>{

    fn new() -> Self{

        let (sender, receiver) = channel::<T>();
        let res = std::thread::spawn(move || {
           loop {
               let s : T = receiver.recv().unwrap();
               s();

           }
        });

        SingleThreadExecutor{
            sender: Mutex::new(sender),
            joinhandle: res,
            close: Mutex::new(false),
        }


    }

    fn submit(&self, t: T) -> Option<()> {
        let res = self.sender.lock().unwrap();
        let state = self.close.lock().unwrap();
        if *state {
            return None;
        }
        (*res).send(t).unwrap();
        Some(())
    }

    fn close(&self){
        let mut state = self.close.lock().unwrap();
        *state = true;
    }

    fn join(&self){


        /*
        let t : T = move || self.joinhandle.join().unwrap();
        self.submit(t);*/
        //self.joinhandle.join().unwrap();
    }
}

fn main() {
    let r = Arc::new(SingleThreadExecutor::new());

    let mut join = Vec::new();

    let r1 = r.clone();

    join.push(thread::spawn(move || {
        for i in 0..10 {
            let state = r1.sender.lock().unwrap();
            state.send(move ||{println!("Task completato {}", i); std::thread::sleep(Duration::from_secs(1))});
            drop(state);
        }

        }));

    let r2 = r.clone();

    join.push(std::thread::spawn(move || {
        std::thread::sleep(Duration::from_secs(2));
        r2.close();
    }));

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


}