How to Prevent Tokio from Dropping Tasks When Threads Are Exhausted

Tokio is the most popular asynchronous runtime in the Rust ecosystem. While its non‑blocking nature gives excellent performance, in real projects you may need to block task creation when resources are scarce.

Problem demonstration

The following program creates a multi‑threaded runtime with only one worker thread and spawns 100 asynchronous tasks. The expected behavior is that each task prints “spawn i”, but the actual output shows that many spawn messages are missing because Tokio discards tasks when the thread pool is saturated.

fn main(){
    let max_task = 1;
    let rt = runtime::Builder::new_multi_thread()
        .worker_threads(max_task)
        .build()
        .unwrap();
    rt.block_on(async {
        println!("tokio_multi_thread ");
        for i in 0..100 {
            println!("run {}", i);
            tokio::spawn(async move {
                println!("spawn {}", i);
                thread::sleep(Duration::from_secs(2));
            });
        }
    });
}

The observed output lists many “run” lines but only a subset of “spawn” lines, stopping after about 59 spawns.

Solution with a bounded task set

By using JoinSet we can limit the number of concurrent tasks. The runtime is created with the desired number of worker threads, and before spawning a new task we wait until the set’s length drops below the limit.

fn main(){
    let max_task = 2;
    let rt = runtime::Builder::new_multi_thread()
        .worker_threads(max_task)
        .enable_time()
        .build()
        .unwrap();
    let mut set = JoinSet::new();
    rt.block_on(async {
        for i in 0..100 {
            println!("run {}", i);
            while set.len() >= max_task {
                set.join_next().await;
            }
            set.spawn(async move {
                sleep().await;
                println!("spawn {}", i);
            });
        }
        while set.len() > 0 {
            set.join_next().await;
        }
    });
}

This approach ensures that at most max_task tasks are active simultaneously; additional tasks block until a slot becomes free, preventing Tokio from dropping work.

The final output shows interleaved “run” and “spawn” lines for all 100 iterations, confirming the expected behavior.

Feel free to try the code yourself.