Race condition in tutorial code example on website

[32h8]

So I think i found a race condition in code example in tutorial.
In this tutorial section there is implementation of Delay future.
The issue occurs when the Delay future migrates across tasks while it executes. Basically, the spawned thread calls wake on an old Waker, and the task gets stuck at await point.

I created a repo with example tweaked to show race condition: repo

I also noticed the webiste links to other Delay implementation that is different than one displayed on website. The issue doesn't occur in that implementation.

[32h8]

Below is tutorial code with added comment where issue occurs.

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, Instant};

struct Delay {
    when: Instant,
    waker: Option<Arc<Mutex<Waker>>>,
}

impl Future for Delay {
    type Output = ();

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {

        if Instant::now() >= self.when {
            return Poll::Ready(());
        }

        // HERE:
        // consider the 2nd call to poll is here and the spawned thread (by 1st poll) calls stored waker here.
        // if the 2nd poll call has different waker then it will never be called. 

        if let Some(waker) = &self.waker {
            let mut waker = waker.lock().unwrap();


            if !waker.will_wake(cx.waker()) {
                *waker = cx.waker().clone();
            }
        } else {
            let when = self.when;
            let waker = Arc::new(Mutex::new(cx.waker().clone()));
            self.waker = Some(waker.clone());

            thread::spawn(move || {
                let now = Instant::now();

                if now < when {
                    thread::sleep(when - now);
                }

                let waker = waker.lock().unwrap();
                waker.wake_by_ref();
            });
        }
        Poll::Pending
    }
}