Best practice for running some async tasks on a dedicated thread

[ririsoft]

Hello,

I would like to understand what is the best practice for running some asynchronous tasks on a dedicated thread, please.

My application is using tokio broadcast channels to notify for internal events. Some event receivers are fine to run concurrently with other tasks managed by tokio runtime. However I would like to have a dedicated thread for a receiver which will log events to some place. The objective here is to minimize lagging.

Let 's see options I have (not warranted to compile, just some thoughts):

Option 1: spawn_blocking and futures::executor::block_on

let (tx, rx) = broadcast::channel(10);
let my_logger = MyAsyncLogger::new();

tokio::task::spawn_blocking(move || {
    futures::executor::block_on(async move {
        loop {
            // lagging is handled in real life
            let evt = rx.recv().await.unwrap();
            my_logger.log(evt).await;
        }
    });
});

I feel like using futures::executor::block_on is an issue but I do not understand why !

Option 2: spawn_blocking and tokio::runtime::Handle::block_on

let (tx, rx) = broadcast::channel(10);
let my_logger = MyAsyncLogger::new();

tokio::task::spawn_blocking(move || {
    Handle::current().block_on(async move {
        loop {
            // lagging is handled in real life
            let evt = rx.recv().await.unwrap();
            my_logger.log(evt).await;
        }
    });
});

I feel like this is the right way to do but do not understand why I should use spawn_blocking instead of a regular std::thread !
Note: this works because timers are already handled by tokio running on main() as per documentation for tokio::runtime::Handle::block_on

Option 3: std::thread::spawn with best of option 1 or option 2 block_on.

I feel like this should work, but do not understand the difference with spawn_blocking.

I had a look at tracing appender, but it is using blocking channels internally, which is not an option for me since some events are still to be processed asynchronously by other tasks.

What would your recommendation be ? Other options ?
Thank you very much in advance for your help.

[Darksonn]

Due to your use of recv inside the thread, you should not use spawn_blocking. Use std::thread::spawn instead. You can read why here. As for block_on, use the one on Handle. See also this post.