[1]: https://docs.rs/tokio/1.41.1/src/tokio/time/sleep.rs.html#12...
I’m not a Rust programmer but I strongly suspect this updated explanation is erroneous. It’s probably more like this: start time is recorded when the task execution is started. However, the task immediately yields control back to the async loop. Then the async loop starts another task, and so on. It’s just that the async loop only returns the control to sleeping task no earlier than the moment 1s passes after the task execution was initialy started. I’d be surprised if it had anything to do with when sleep() was called.
On the other hand, I maintain that this is an incidental rather than essential reason for the program finishing quickly. In that benchmark code, we can replace "sleep" with our custom sleep function which does not record start time before execution:
async fn wrapped_sleep(d: Duration) {
sleep(d).await
}
The following program will still finish in ~10 seconds. #[tokio::main]
async fn main() {
let num_tasks = 100;
let mut tasks = Vec::new();
for _ in 0..num_tasks {
tasks.push(wrapped_sleep(Duration::from_secs(10)));
}
futures::future::join_all(tasks).await;
}Regardless, the program you provided _does_ actually run the futures concurrently, because of the `join_all()`. My point above was that in the original blog post, the appendix has a version without `join_all()`, which has no concurrency.
Am I wrong?
UPDATE: From the replies below, it looks like I was right about "no concurrency takes place", but I was wrong about how long it takes, because `tokio::time::sleep()` keeps track of when the future was created, (ie when `sleep()` was called) instead of when the future is first `.await`ed (which was my unsaid assumption).