How to use Handle block_on on a current thread runtime

[Guara92]

Hi, consider this example code:

#[tokio::main(flavor = "current_thread")]
async fn main() {
    call_sync();
}

pub fn call_sync() {
    let handle = Handle::current();
    let five = std::thread::spawn(move || {
        handle.block_on(get_five_async())
    })
    .join()
    .unwrap();

    println!("{five:?}");
}

pub async fn get_five_async() -> i32 {
    sleep(core::time::Duration::from_millis(100)).await;
    5
}

with a current_thread runtime, the future never ends, there is a way to do this?

[Darksonn]

This fails because the timer driver runs on the main thread, but by calling the blocking call_sync method on the main thread, you never yield back to the runtime, and so the timer driver is never able to notify any of its timers that they have completed. Even if you make call_sync async, then the same issue will appear because then you are calling the blocking std::thread::JoinHandle::join method.

To fix this, change call_sync to be async, then use an asynchronous way to wait for the thread to complete:

use tokio::runtime::Handle;
use tokio::sync::oneshot;
use tokio::time::sleep;

#[tokio::main(flavor = "current_thread")]
async fn main() {
    call_sync().await;
}

pub async fn call_sync() {
    let (send, recv) = oneshot::channel();

    let handle = Handle::current();
    std::thread::spawn(move || {
        let res = handle.block_on(get_five_async());
        let _ = send.send(res);
    });
    let five = recv.await;

    println!("{five:?}");
}

pub async fn get_five_async() -> i32 {
    sleep(core::time::Duration::from_millis(100)).await;
    5
}

You can also use spawn_blocking to spawn the thread:

use tokio::runtime::Handle;
use tokio::time::sleep;

#[tokio::main(flavor = "current_thread")]
async fn main() {
    call_sync().await;
}

pub async fn call_sync() {
    let handle = Handle::current();
    let five = tokio::task::spawn_blocking(move || {
        handle.block_on(get_five_async())
    }).await.unwrap();

    println!("{five:?}");
}

pub async fn get_five_async() -> i32 {
    sleep(core::time::Duration::from_millis(100)).await;
    5
}

You can read more about blocking the thread in this article.

[brandonros]

With a multi-threaded runtime, can you have multiple block_in_place tasks running at the same time without basically reducing the app down to single-threaded "one task waits for another blocking wise"?

[Darksonn]

When you call block_in_place, the runtime will spawn a new worker thread to compensate.

That said, there is a limit to this. Every block_in_place call will essentially reduce the size of the spawn_blocking pool by one, and if it reaches zero, it will no longer spawn new worker threads. The default size of the pool is 512.

[brandonros]

pub fn http_request(request_url: String, request_body_buffer: Vec<u8>) -> hyper::body::Bytes {
  info!("http_request: {}", request_url);
  let _guard = client_runtime.enter();
  let join_handle = tokio::spawn(async {
    return async_http_request(request_url, request_body_buffer).await;
  });
  return futures::executor::block_on(join_handle).unwrap();
}

I'm not sure why that does something different than runtime.block_on. Could you explain what/why (if you know)?

[Darksonn]

Open a new question if you have a new question.

[DarumaDockerDev]

Yes, the real problem is that this code is inside an actix-web handler that runs on a single-threaded runtime and I can't use block_in_place, thanks anyway.

@Guara92 I'm facing the same issue. Is your problem solved?