How to handle long running blocking calls?

[overthetop]

What is the correct way to run blocking calls that could possibly take more time? Is there a way to configure a separate thread pool that handle these? Also be able to specify the pool size.
What I'd like to do is something like this:

async fn slow_handler() -> Result<impl IntoResponse, StatusCode> {
    
        // run this in a separate thread pool
        // also be able to configure this thread pool size

        std::thread::sleep(tokio::time::Duration::from_millis(2*1000));
        let dto = ReturnDTO {
            return_type: std::thread::current().name().unwrap().to_string(),
        };
        Ok(Json(dto))
} 

[syphar]

It looks like the request will wait for the task to finish, right?

The "default" way to do this is to use tokio::task::spawn_blocking, which uses a separate threadpool, with configurable size.

You can also totally use a separate threadpool for this, as long as you asynchronously wait for the task.

[overthetop]

@syphar thanks for the answer. Can you please provide the axum handler code that uses [tokio::task::spawn_blocking]? I'm a complete rust noob and that will help a lot.

[overthetop]

I think I've made it

async fn slow_handler() -> Result<impl IntoResponse, StatusCode> {
    tokio::task::spawn_blocking(move || {
        std::thread::sleep(tokio::time::Duration::from_millis(10));
        let dto = ReturnDTO {
            return_type: std::thread::current().name().unwrap().to_string(),
        };        
        Ok(Json(dto))
    })
    .await
    .unwrap()
}