Join thread with a timeout

main.rs

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

struct MyJoin<T> {
    handle: thread::JoinHandle<T>,
    signal: Receiver<()>
}

impl<T> MyJoin<T> {
    fn join(self, timeout: Duration) -> Result<T, Self> {
        if let Err(_) = self.signal.recv_timeout(timeout) {
            return Err(self)
        }
        Ok(self.handle.join().unwrap())
    }
}

fn my_spawn<T: Send + 'static, F: FnOnce() -> T + Send + 'static>(f: F) -> MyJoin<T> {
    let (send, recv) = channel();
    let t = thread::spawn(move || {
        let x = f();
        send.send(()).unwrap();
        x
    });
    MyJoin {
        handle: t,
        signal: recv
    }
}

fn main() {
    let mut j = my_spawn(|| std::thread::sleep(Duration::from_secs(1)));
    
    loop {
        match j.join(Duration::from_millis(100)) {
            Ok(_) => return,
            Err(x) => {
                println!("Failed to join within a timeout");
                j = x
            }
        }
    }
}