When should a thread generally yield?

问题

In most languages/frameworks, there exists a way for a thread to yield control to other threads. However, I can't really think of a time when yielding from a thread was the correct solution to a given problem. When, in general, should one use Thread.yield(), sleep(0), etc?

回答1:

One use case could be for testing concurrent programs, try to find interleavings that reveal flaws in your synchronization patterns. For instance in Java:

A useful trick for increasing the number of interleavings, and therefore more effectively exploring the state space of your programs, is to use Thread.yield to encourage more context switches during operations that access shared state. (The effectiveness of this technique is platform-specific, since the JVM is free to treat THRead.yield as a no-op [JLS 17.9]; using a short but nonzero sleep would be slower but more reliable.) — JCIP

Also interesting from the Java point of view is that their semantics are not defined:

The semantics of Thread.yield (and Thread.sleep(0)) are undefined [JLS 17.9]; the JVM is free to implement them as no-ops or treat them as scheduling hints. In particular, they are not required to have the semantics of sleep(0) on Unix systemsput the current thread at the end of the run queue for that priority, yielding to other threads of the same prioritythough some JVMs implement yield in this way. — JCIP

This makes them, of course, rather unreliable. This is very Java specific, however, in generally I believe following is true:

Both are low-level mechanism which can be used to influence the scheduling order. If this is used to achieve a certain functionality then this functionality is based on the probability of the OS scheduler which seems a rather bad idea. This should be managed by higher-level synchronization constructs instead.

For testing purpose or for forcing the program into a certain state it seems a handy tool.

回答2:

Keep your OS scheduler decide for you ?

So never yield, and never sleep(0) until you match a case where sleep(0) is absolutly necessary and document it here.

Also context switch are costy so I don't think a lot of people want more context switches.

回答3:

When, in general, should one use Thread.yield(), sleep(0), etc?

It depends on the VM are thread model we are talking about. For me the answer is rarely if ever.

Traditionally some thread models were non-preemptive and others are (or were) not mature hence the need for Thread.yield().

I feel that Thread.yield() is like using register in C. We used to rely on it to improve the performance of our programs because in many cases the programmer was better at this than the compiler. But modern compilers are much smarter and in much fewer cases these days can the programmer actually improve the performance of a program with the use of register and Thread.yield().

来源：https://stackoverflow.com/questions/14654532/when-should-a-thread-generally-yield