What is the meaning of yield_now in multi-thread runtime?

[Fancyflame]

yield_now may act randomly:
playground

use std::sync::{
    atomic::{AtomicBool, Ordering::Relaxed},
    Arc,
};
use tokio::task;

#[tokio::main]
async fn main() {
    let mut succeed = 0;
    let mut failed = 0;
    for _ in 0..10000 {
        if test().await {
            succeed += 1;
        } else {
            failed += 1;
        }
    }

    println!("testing done. succeed {succeed}, failed {failed}");
}

async fn test() -> bool {
    let arc = Arc::new(AtomicBool::new(false));
    let arc_cloned = arc.clone();
    let handle = task::spawn(async move {
        // if the spawned task execute later, testing is failed
        arc_cloned.store(false, Relaxed);
    });

    task::yield_now().await;
    task::yield_now().await;

    // if main task execute later, testing is succeed
    arc.store(true, Relaxed);
    
    handle.await.unwrap();
    arc.load(Relaxed)
}

The result is

testing done. succeed 237, failed 9763

[Darksonn]

The main function runs inside a block_on call, which means that it runs outside of the runtime's thread pool. This means that the tokio::spawn calls are not executed on the same thread as the test method, so yielding in the test method does not affect the execution of your spawned tasks.

Try executing your test inside the runtime threadpool instead:

#[tokio::main]
async fn main() {
    tokio::spawn(async move {
        let mut succeed = 0;
        let mut failed = 0;
        for _ in 0..10000 {
            if test().await {
                succeed += 1;
            } else {
                failed += 1;
            }
        }
    
        println!("testing done. succeed {succeed}, failed {failed}");
    }).await.unwrap();
}

testing done. succeed 10000, failed 0

However, please be warned that this behavior is not guaranteed! If other tasks are running on the runtime, then you may see failures. The yield_now function should be used only as a performance optimization.

[Fancyflame]

Thanks! But why might other tasks affect the result?

[Darksonn]

Because of work stealing. If your spawned task gets stolen by another worker thread, then the yield will no longer put you in the same queue as the spawned task. When they end up in different queues, there are no guarantees about which one will execute first.