Class Threaded

Instruction --+    
              |    
          Stage --+
                  |
                 Threaded

A stage which runs a blocking iterable in a separate thread

This stage tunnels output from an iterable executed in a separate
thread to the main thread.   This process is carried out by 
a result buffer, and returning Cooperate if the buffer is
empty.   The wrapped iterable's __iter__ and next() methods
will only be invoked in the spawned thread.

This can be used in one of two ways, first, it can be 
extended via inheritance; with the functionality of the
inherited code implementing next(), and using init() for
initialization code to be run in the thread.

If the iterable happens to have a chunked attribute, and
that attribute is true, then this wrapper will assume that
data arrives in chunks via a sequence instead of by values.

    from __future__ import generators
    from twisted.internet import reactor, defer
    from twisted.flow import flow
    from twisted.flow.threads import Threaded
    
    def countSleep(index):
        from time import sleep
        for index in range(index):
            sleep(.3)
            print "sleep", index
            yield index
    
    def countCooperate(index):
        for index in range(index):
            yield flow.Cooperate(.1)
            print "cooperate", index
            yield "coop %s" % index
    
    d = flow.Deferred( flow.Merge(
            Threaded(countSleep(5)),
            countCooperate(5)))
    
    def prn(x):
        print x
        reactor.stop()
    d.addCallback(prn)
    reactor.run()