CODEWITHSUNDEEP
rustasync-awaitinfinite-loop
Keval Bhogayata
Keval Bhogayata

Reputation: 6756

Is it possible to write an asynchronous loop inside synchronous function?

This is my current Rust code

async fn test() {
    ........
    loop {
        ......
        set_timeout(Duration::from_secs(5)).await;
    }
}

I want to make my function synchronous, can I do something like ...

fn test() {
    loop {
        async {
            ......
            set_timeout(Duration::from_secs(5)).await;
        }
    }
}

I tried something as shown above, I removed async keyword from the function and created an async block inside loop, but after this changes, my code somehow becomes unreachable,

How can I keep my "test" function synchronous and still make my code reachable?!

Upvotes: 1

Views: 1650

Answers (1)

Chayim Friedman
Chayim Friedman

Reputation: 71535

The code with the async block is unreachable since an async block does not execute the code inside, rather it creates a future that when will be .awaited will execute the code inside.

To execute an asynchronous code inside a synchronous function you need to block. The functions for that are usually provided by the async runtime you use. For example, tokio has block_on() (and a bunch of other functions). You do it like:

tokio::runtime::Runtime::new().unwrap().handle().block_on(async {
    // ...
});
// Or by re-using the current runtime, if you have an active one:
tokio::runtime::Handle::current().block_on(async {
    // ...
});

There is a runtime-agnostic block_on() function provided by the futures crate, although using it is likely to be less performant and/or interfere with the runtime.

Note that blocking while you're executing asynchronous code (if the outer function is called by async code) is bad and may have serious implications.

Upvotes: 4

Related Questions