Does Thread.yield() do anything if we have enough processors to service all threads?

Question

If we are in a situation with two running threads on a machine with two processors and we call Thread.yield() within one of those threads, does it stand to reason that nothing will happen (the scheduler will essentially ignore the request) because we have enough processors to service the running threads?

Answer 1

Whenever a thread calls the Thread.yield() method, it gives a hint to the thread scheduler that it is ready to pause its execution. The thread scheduler is free to ignore this hint.

If any thread executes the yield method, the thread scheduler checks if there is any runnable (waiting to be executed) thread with same or high priority than this thread. If the processor finds any thread with higher or same priority then it will switch to a new thread. If not, the current thread keeps executing.

Since, in your example, you have enough processors to service all the Threads (they are running, not waiting in a runnable state); Thread.yield() will do nothing, and your threads will continue their execution.

A note about Windows, from Microsoft DOTNet:

This method is equivalent to using platform invoke to call the native Win32 SwitchToThread function.

Yielding is limited to the processor that is executing the calling thread. The operating system will not switch execution to another processor, even if that processor is idle or is running a thread of lower priority. If there are no other threads that are ready to execute on the current processor, the operating system does not yield execution

So there may be caveats in some situations.

Answer 2

Thread.yield() is obsolete. Unless your program is going to run on a platform that implements cooperative multitasking or on a JVM that still uses green threads, then there is no point in calling it.

The standard library Javadoc for Thread.yield() effectively says that yield() does not have to do anything at all.

Answer 3

I always thought that Thread::yield should be replaced with Thread::onSpinWait (since java 9) - that is just a form of a "weaker" yield, until I saw a usage of both in StampedLock:

    else if ((LockSupport.nextSecondarySeed() & OVERFLOW_YIELD_RATE) == 0)
        Thread.yield();
    else
        Thread.onSpinWait();
    return 0L;

So I don't think it is obsolete. Internally in the jdk sources it has many usages, even the relatively new ForkJoinPool has usages of Thread::yield.

In practice, I have only used Thread::onSpinWait inside busy spins - because at least from the name of it - it is very clear when to use it; yielding on the other hand is not - so I can't tell for sure when and how to use it.

Just my 0.02$.