4

I'm experimenting with tokio's tokio::spawn and tokio::task::spawn and turns out I don't understand how the latter behaves.

When I run the following code:

#[tokio::main]
pub async fn main() {
    // I'm spawning one block of functions
    let h = tokio::task::spawn_blocking(move || {
        block_one();
    });

    // and another block of functions
    let h2 = tokio::spawn(async move {
        block_two().await;
    });

    // then I collect the handles
    h.await.unwrap();
    h2.await.unwrap();
}

#[tokio::main] //needed as this block is not treated as syncronous by main
pub async fn block_one() {
    let mut handles = vec![];

    for i in 1..10 {
        let h = tokio::spawn(async move {
            println!("Starting func #{}", i);
            i_take_random_time().await;
            println!("Ending func #{}", i);
        });
        handles.push(h);
    }

    for h in handles {
        h.await.unwrap();
    }
}

pub async fn block_two() {
    let mut handles = vec![];

    for i in 10001..10010 {
        let h = tokio::spawn(async move {
            println!("Starting func #{}", i);
            i_take_random_time().await;
            println!("Ending func #{}", i);
        });
        handles.push(h);
    }

    for h in handles {
        h.await.unwrap();
    }
}

My expectation is that the first block of functions will run in full - only then the second block will run. That's how I understand "spawn_blocking" - it blocks futher execution until whatever's inside of it is done.

What I actually get is that the second block of functions starts first (in full, all 10 of them) - only then the first block starts. So it's exactly backwards from what I expected.

To further confuse things, when I modify the above code to have spawn_blocking for both blocks - all the 20 functions start together, as if both blocks are part of one big async loop. Again not what I expected - I would think the first block would run, blocking before it's done, and THEN the second would run.

Can someone help me decipher what's going on?

The full code to reproduce the 2 scenarios above is available in this repo.

  • scenario 5 = the first case I described
  • scenario 6 = the second case I described

Note: there's two levels of asynchronicity here: BETWEEN blocks and WITHIN blocks. Hope helps avoid any confusion.

ilmoi
  • 1,994
  • 2
  • 21
  • 45
  • 2
    I've not read through your whole question yet, but you almost certainly don't want to annotate `block_one` with `#[tokio::main]`. This is usually only done on the actual `main` function of your executable, since it creates a runtime for you. It's likely that you have (at least) two runtimes here, which might explain some of the indeterminate behavior. – bnaecker Jun 15 '21 at 17:00
  • The use of `#[tokio::main]` is indeed not what you want since it spawns a new runtime and a whole bunch of threads, but it is not the reason behind the confusion. – Alice Ryhl Jun 16 '21 at 11:33

1 Answers1

9

It sounds like you expect spawn_blocking to block other things from running, but its purpose is the exact opposite. The purpose of spawn_blocking is to avoid blocking other things from running.

The main place where spawn_blocking is used is for operations that would otherwise block the thread due to their use of non-async operations such as std::net. It does this by offloading them to a separate thread pool. The name comes from the fact that you are spawning a blocking operation so it can run elsewhere.

To wait for the first block to finish, you would do this:

#[tokio::main]
pub async fn main() {
    // I'm spawning one block of functions
    let h = tokio::task::spawn_blocking(move || {
        block_one();
    });

    // wait for the first block
    h.await.unwrap();

    // then spawn another block of functions
    let h2 = tokio::spawn(async move {
        block_two().await;
    });

    h2.await.unwrap();
}

Note that using #[tokio::main] (or block_on) immediately inside spawn_blocking is very rarely what you want. Just spawn an ordinary task with tokio::spawn.

Alice Ryhl
  • 3,574
  • 1
  • 18
  • 37