Hyper client concurrent excution take twice as much time comparing to parallel

[AndrewKovalenko]

If I try to send 100 http requests concurently with code below - I get avg completion time ~600ms

        const TEST_URI: &str = "https://jsonplaceholder.typicode.com/todos/1";
.....
        let http_client = creat_http_client();

        future::join_all((0..total_requests).map(|_| {
            let client = &http_client;
            async move {
                let resource_uri = TEST_URI.parse().unwrap();

                let mut response = client.get(resource_uri).await.unwrap();
                println!("[Concurrent] Response: {}", response.status());


                while let Some(chunk) = response.body_mut().data().await {
                    stdout().write_all(&chunk.unwrap()).await.unwrap();
                }
            }
        }))
        .await;

however when I modify to remove concurency - avg. execution time drops to ~280ms

        let http_client = creat_http_client();

        future::join_all((0..total_requests).map(|_| {
            let client = http_client.clone();                // <- separate instance of the http client for every request

           tokio::spawn(                                           // <- spawn a task instead of async code block call
            async move {
                let resource_uri = TEST_URI.parse().unwrap();

                let mut response = client.get(resource_uri).await.unwrap();
                println!("[Parallel] Response: {}", response.status());


                while let Some(chunk) = response.body_mut().data().await {
                    stdout().write_all(&chunk.unwrap()).await.unwrap();
                }
            }
        )
        })).await;

Could you please help me understand what does cause such a huge performance difference?

[seanmonstar]

Is the Tokio you're using a mutli-threaded runtime? If so, then spawning is allowing other threads to work at the same time.

[AndrewKovalenko]

Thank you for answering! I'm still learning Rust stack and perhaps I miss-understood how async move from the first example works.
Do you say that async move without tokio::spawn just executes response processing asynchronously but in the same thread?

[seanmonstar]

Yes, Rust async allows polling multiple things on the same thread. But spawn allows that same power across multiple threads.

This is a very useful tutorial: https://tokio.rs/tokio/tutorial