Implementierung eines threadsicheren asynchronen Timer-Futures von Grund auf

use std::future::Future;
use std::pin::Pin;
use std::sync::{Arc, Mutex};
use std::task::{Context, Poll, Waker};
use std::thread;
use std::time::Duration;
 
struct AsyncTimer {
    state: Arc<Mutex<TimerState>>,
}
 
struct TimerState {
    completed: bool,
    waker: Option<Waker>,
}
 
impl Future for AsyncTimer {
    type Output = ();
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let mut state = self.state.lock().unwrap();
        if state.completed {
            Poll::Ready(())
        } else {
            state.waker = Some(cx.waker().clone());
            Poll::Pending
        }
    }
}
 
impl AsyncTimer {
    fn new(duration: Duration) -> Self {
        let state = Arc::new(Mutex::new(TimerState { completed: false, waker: None }));
        let thread_state = state.clone();
        thread::spawn(move || {
            thread::sleep(duration);
            let mut state = thread_state.lock().unwrap();
            state.completed = true;
            if let Some(waker) = state.waker.take() {
                waker.wake();
            }
        });
        AsyncTimer { state }
    }
}