Writing ubiquitously threaded code is still an uncommon practice, as not all problems are suited to threads--and this is unlikely to change any time soon. When problems are suited for threading, good threaded code is hard to craft. This paper steps into the future, introducing an original synchronization construct diminutively called “yield.”

Rather than a throwback from cooperative multitasking, yield becomes, in the hands of Yi and Flanagan, a primitive construct suited to reasoning about concurrency in a fully preemptive environment, endowed with original properties and substantial theoretical support. Instead of being another form of locking to guarantee sequential execution, yield is a specification that indicates where context switches are allowed to happen or where interference with sequential execution may occur. As Yi and Flanagan state: “An atomic method is simply one that can never execute a yield annotation.” Yield does not replace locks; it works synergistically as an aid to enable static analysis of the correctness of synchronization, even when such code is executed in a dynamic, preemptive environment. Code written with locks and yield annotations appears susceptible to automated verification that serialization will happen without race conditions.

If this promise--tool support for static analysis of correctness--can be realized in practice, this paper promises to become quite popular. Correctness does not guarantee better performance, which is the ultimate goal of multi-threaded execution, yet a guarantee of correctness will encourage audacity in its pursuit. Since great ideas are seldom born in a vacuum, the paper includes a rich list of references upon which it builds.