Why does the task execute without await?

[khassar00]

`
use chrono::Local;
use tokio::spawn;

#[tokio::test]
async fn test() {
let task1= spawn(async move{
time_print("task1 start".to_string());
tokio::time::sleep(Duration::from_millis(100)).await;
time_print("task1 complete".to_string());
});
let task2= spawn(async move{
time_print("task2 start".to_string());
tokio::time::sleep(Duration::from_millis(100)).await;
time_print("task2 complete".to_string());
});
time_print("task1 await start".to_string());
task1.await.unwrap();
time_print("task1 await complete".to_string());

}
fn time_print(string:String){
println!("{}:{string}", Local::now());
}
`
result:
2022-11-17 15:00:14.527949400 +08:00:task1 await start
2022-11-17 15:00:14.529036600 +08:00:task1 start
2022-11-17 15:00:14.529089 +08:00:task2 start
2022-11-17 15:00:14.636851800 +08:00:task1 complete
2022-11-17 15:00:14.636913600 +08:00:task2 complete
2022-11-17 15:00:14.636983100 +08:00:task1 await complete

Why does the task2 execute without await?
I'm just starting to learn rust. Am I missing anything?

[Darksonn]

This is the difference between tokio::spawn and other futures. With most normal futures, they don't execute until you .await them, but tokio::spawn is different: the task starts executing in the background immediately, and using .await on the returned JoinHandle is just a way to wait for it to finish — it doesn't affect the execution of the task.

This means that this:

let mut handles = Vec::new();
for i in num_tasks {
    handles.push(tokio::spawn(start_task(i)));
}
let mut outputs = Vec::new();
for handle in handles {
    outputs.push(handle.await.unwrap());
}

will execute all num_tasks tasks in parallel, even though only one JoinHandle is .awaited at the time.