Why does it seem async client not reusable across tasks? #2075

zhengtong0898 · 2023-12-27T08:36:10Z

zhengtong0898
Dec 27, 2023

I want to reuse the async client across multiple tasks, but I am encountering blocking issues. In Code-A, after executing print_main_page, subsequent await calls in the main function lead to deadlocks.

Code-A

use reqwest::Client;
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::RwLock;

struct Site {
    url: String,
}

impl Site {
    async fn print_main_page(&self, client: Client) {
        let response = client.get(&self.url).send().await.unwrap();
        let text = response.text().await.unwrap();
        println!("content preview: {} ...ignore...", text.get(0..50).unwrap());
    }
}

#[tokio::main]
async fn main() {
    let client = Client::builder()
        .proxy(reqwest::Proxy::all("http://127.0.0.1:7890").unwrap())
        .build()
        .unwrap();
    let url = String::from("https://www.google.com");
    let google = Arc::new(RwLock::new(Site { url }));

    let google_clone = google.clone();
    let client_clone = client.clone();
    tokio::spawn(async move {
        {
            let guard = google_clone.read().await;
            guard.print_main_page(client_clone).await;
        }

        println!("----a----");
        // long running
        loop {}
    });

    let mut count = 1;
    loop {
        println!("----b----");
        let guard = google.read().await;
        println!("count: {count}: {:?}", guard.url);
        count += 1;
        tokio::time::sleep(Duration::from_secs(1)).await;
        println!("----c----");
    }
}

Code-A output:
The code never reaches "----c----".

----b----
count: 1: "https://www.google.com"
content preview: <!doctype html><html itemscope="" itemtype="http:/ ...ignore...
----a----

When I move the initialization of the async client into the print_main_page function (meaning the async client is not reused), the code does not block.

Code-B

use reqwest::Client;
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::RwLock;

struct Site {
    url: String,
}

impl Site {
    async fn print_main_page(&self) {
        let client = Client::builder()
            .proxy(reqwest::Proxy::all("http://127.0.0.1:7890").unwrap())
            .build()
            .unwrap();
        let response = client.get(&self.url).send().await.unwrap();
        let text = response.text().await.unwrap();
        println!("content preview: {} ...ignore...", text.get(0..50).unwrap());
    }
}

#[tokio::main]
async fn main() {
    let url = String::from("https://www.google.com");
    let google = Arc::new(RwLock::new(Site { url }));

    let google_clone = google.clone();
    tokio::spawn(async move {
        {
            let guard = google_clone.read().await;
            guard.print_main_page().await;
        }

        println!("----a----");
        // long running
        loop {}
    });

    let mut count = 1;
    loop {
        println!("----b----");
        let guard = google.read().await;
        println!("count: {count}: {:?}", guard.url);
        count += 1;
        tokio::time::sleep(Duration::from_secs(1)).await;
        println!("----c----");
    }
}

Code-B outout:

----b----
count: 1: "https://www.google.com"
content preview: <!doctype html><html itemscope="" itemtype="http:/ ...ignore...
----a----
----c----
----b----
count: 2: "https://www.google.com"
----c----
----b----
count: 3: "https://www.google.com"
----c----
----b----
count: 4: "https://www.google.com"
----c----
----b----
count: 5: "https://www.google.com"
----c----
----b----
count: 6: "https://www.google.com"
----c----
----b----

Is this caused by my incorrect usage? Thanks for any help!

Answered by seanmonstar

Dec 27, 2023

There's nothing in reqwest::Client that is blocking, you should be able to use it across multiple tasks.

Could the loop {} in your spawned task be the problem? It will never yield, and if you're using a single threaded Tokio runtime, then when it's looping forever, the other task can never run.

View full answer

seanmonstar · 2023-12-27T15:00:17Z

seanmonstar
Dec 27, 2023
Maintainer

There's nothing in reqwest::Client that is blocking, you should be able to use it across multiple tasks.

Could the loop {} in your spawned task be the problem? It will never yield, and if you're using a single threaded Tokio runtime, then when it's looping forever, the other task can never run.

1 reply

zhengtong0898 Dec 27, 2023
Author

Thanks for the quick reply!

I learned from the documentation that #[tokio::main] uses a multi-threaded mode. I observed by adding code (std::thread::current().id()) that the thread IDs of different tasks are different, so loop {} should not cause blocking.

After some trials, I also found that if I launch another task (tokio::spawn) to run print_main_page, then there will be no blocking at all.

Code-C

use reqwest::Client;
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::RwLock;

struct Site {
    url: String,
}

impl Site {
    async fn print_main_page(&self, client: Client) {
        let request = client.get(&self.url).build().unwrap();
        let response = client.execute(request).await.unwrap();
        let _ = response.text().await.unwrap();
        println!("spawn_print: thread_id: {:?}", std::thread::current().id());
    }
}

#[tokio::main(flavor = "multi_thread", worker_threads = 10)]
async fn main() {
    let url = String::from("https://www.google.com");
    let google = Arc::new(RwLock::new(Site { url }));
    let client = Client::builder()
        .proxy(reqwest::Proxy::all("http://127.0.0.1:7890").unwrap())
        .build()
        .unwrap();

    let google_clone = google.clone();
    let client_clone = client.clone();
    tokio::spawn(async move {
        tokio::spawn(async move {
            let guard = google_clone.read().await;
            guard.print_main_page(client_clone).await;
        })
        .await
        .unwrap();

        println!("spawn_loop : thread_id: {:?}", std::thread::current().id());
        // long running
        loop {}
    });

    let mut count = 1;
    loop {
        let guard = google.read().await;
        println!(
            "main_loop  : thread_id: {:?}: count: {count}: url: {}",
            std::thread::current().id(),
            guard.url
        );

        count += 1;
        tokio::time::sleep(Duration::from_secs(1)).await;
    }
}

Code-C output:

main_loop  : thread_id: ThreadId(1): count: 1: url: https://www.google.com
spawn_print: thread_id: ThreadId(10)
spawn_loop : thread_id: ThreadId(10)
main_loop  : thread_id: ThreadId(1): count: 2: url: https://www.google.com
main_loop  : thread_id: ThreadId(1): count: 3: url: https://www.google.com
main_loop  : thread_id: ThreadId(1): count: 4: url: https://www.google.com
main_loop  : thread_id: ThreadId(1): count: 5: url: https://www.google.com
main_loop  : thread_id: ThreadId(1): count: 6: url: https://www.google.com
main_loop  : thread_id: ThreadId(1): count: 7: url: https://www.google.com

I'm not sure why this happens, but it seems like it's not an issue with the async client. I will take this question to the tokio discussion area.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Why does it seem async client not reusable across tasks? #2075

{{title}}

Replies: 1 comment 1 reply

{{title}}

{{title}}

Select a reply

Why does it seem async client not reusable across tasks? #2075

zhengtong0898 Dec 27, 2023

Replies: 1 comment · 1 reply

seanmonstar Dec 27, 2023 Maintainer

zhengtong0898 Dec 27, 2023 Author

zhengtong0898
Dec 27, 2023

Replies: 1 comment 1 reply

seanmonstar
Dec 27, 2023
Maintainer

zhengtong0898 Dec 27, 2023
Author