Editing Coroutine (section)

===Subroutines===
Subroutines are special cases of coroutines.<ref name="KnuthVol1_1_4_2"/> When subroutines are invoked, execution begins at the start, and once a subroutine exits, it is finished; an instance of a subroutine only returns once, and does not hold state between invocations. By contrast, coroutines can exit by calling other coroutines, which may later return to the point where they were invoked in the original coroutine; from the coroutine's point of view, it is not exiting but calling another coroutine.<ref name="KnuthVol1_1_4_2"/> Thus, a coroutine instance holds state, and varies between invocations; there can be multiple instances of a given coroutine at once. The difference between calling another coroutine by means of [[Yield (multithreading)|"yielding"]] to it and simply calling another routine (which then, also, would return to the original point), is that the relationship between two coroutines which yield to each other is not that of caller-callee, but instead symmetric.

Any subroutine can be translated to a coroutine which does not call ''yield''.<ref name="Perlis1982_6"/>

Here is a simple example of how coroutines can be useful. Suppose you have a consumer-producer relationship where one routine creates items and adds them to a queue and another removes items from the queue and uses them. For reasons of efficiency, you want to add and remove several items at once. The code might look like this:

 ''var'' q := new queue
 
 '''coroutine''' produce
     '''loop'''
         '''while''' q is not full
             create some new items
             add the items to q
         '''yield''' to consume
 
 '''coroutine''' consume
     '''loop'''
         '''while''' q is not empty
             remove some items from q
             use the items
         '''yield''' to produce
 
 '''call''' produce

The queue is then completely filled or emptied before yielding control to the other coroutine using the ''yield'' command. The further coroutines calls are starting right after the ''yield'', in the outer coroutine loop.

Although this example is often used as an introduction to [[thread (computing)|multithreading]], two threads are not needed for this: the ''yield'' statement can be implemented by a jump directly from one routine into the other.