tl;dr: use tokio::time

if there's one thing to take away from this: never perform blocking or long-running operations inside of asynchronous operations.

if you want a timeout, use something from tokio::time, such as delay_for or timeout:

use futures::future::{self, either}; // 0.3.1
use std::time::duration;
use tokio::time; // 0.2.9

#[tokio::main]
async fn main() {
    let time_out1 = time::delay_for(duration::from_secs(5));
    let time_out2 = time::delay_for(duration::from_secs(1));

    match future::select(time_out1, time_out2).await {
        either::left(_) => println!("timer 1 finished"),
        either::right(_) => println!("timer 2 finished"),
    }
}

what's the problem?

to understand why you get the behavior you do, you have to understand the implementation of futures at a high level.

when you call run, there's a loop that calls poll on the passed-in future. it loops until the future returns success or failure, otherwise the future isn't done yet.

your implementation of poll "locks up" this loop for 5 seconds because nothing can break the call to sleep. by the time the sleep is done, the future is ready, thus that future is selected.

the implementation of an async timeout conceptually works by checking the clock every time it's polled, saying if enough time has passed or not.

the big difference is that when a future returns that it's not ready, another future can be checked. this is what select does!

a dramatic re-enactment:

sleep-based timer

core: hey select, are you ready to go?

select: hey future1, are you ready to go?

future1: hold on a seconnnnnnnn [... 5 seconds pass ...] nnnnd. yes!

simplistic async-based timer

core: hey select, are you ready to go?

select: hey future1, are you ready to go?

future1: checks watch no.

select: hey future2, are you ready to go?

future2: checks watch no.

core: hey select, are you ready to go?

[... polling continues ...]

[... 1 second passes ...]

core: hey select, are you ready to go?

select: hey future1, are you ready to go?

future1: checks watch no.

select: hey future2, are you ready to go?

future2: checks watch yes!

this simple implementation polls the futures over and over until they are all complete. this is not the most efficient, and not what most executors do.

see how do i execute an async/await function without using any external dependencies? for an implementation of this kind of executor.

smart async-based timer

core: hey select, are you ready to go?

select: hey future1, are you ready to go?

future1: checks watch no, but i'll call you when something changes.

select: hey future2, are you ready to go?

future2: checks watch no, but i'll call you when something changes.

[... core stops polling ...]

[... 1 second passes ...]

future2: hey core, something changed.

core: hey select, are you ready to go?

select: hey future1, are you ready to go?

future1: checks watch no.

select: hey future2, are you ready to go?

future2: checks watch yes!

this more efficient implementation hands a waker to each future when it is polled. when a future is not ready, it saves that waker for later. when something changes, the waker notifies the core of the executor that now would be a good time to re-check the futures. this allows the executor to not perform what is effectively a busy-wait.

the generic solution

when you have have an operation that is blocking or long-running, then the appropriate thing to do is to move that work out of the async loop. see what is the best approach to encapsulate blocking i/o in future-rs? for details and examples.