如何使用python生成器创建非阻塞循环协同程序？

Question

I am using python and I'm experimenting with using generators as coroutines. Meaning that I'm using the yield expression to pass values into the generator and then sending messages back and forth between various of these generator coroutines.

I am trying to chain together coroutines into a loop that iterates a value, whilst remaining open to new values originating from outside the loop. In other words, the loop should be non-blocking:

This is the loop:

coroutine_A -> val = (yield) -> does something to val -> coroutine_B.send(other_val)
coroutine_B -> val = (yield) -> does something to val -> coroutine_C.send(other_val)
coroutine_C -> val = (yield) -> does something to val -> coroutine_A.send(other_val)

And from time to time I want to pass a new value from the outside of this loop to coroutine_A, and then off it goes again.

EXTERNAL TO LOOP -> coroutine_A.send(message) -> loop continues from new value...

The individual pieces work fine, but two issues arise when I try to connect them up. Firstly, how to instantiate these as a loop, which seems doable, but leads to a deeper issue as elaborated on beneath.

THE FIRST ISSUE:

When instantiating coroutine_A, coroutine_B doesn't exist yet, so it isn't yet possible to tell coroutine_A what its message target is. Basically a chicken and egg scenario.

I've tried creating a container function that instances each of these coroutines (without message targets), and then creates a loop that manages the message on behalf of the coroutines like so:

def func():
    A = coroutine_A()
    next(A)
    B = coroutine_B()
    next(B)
    C = coroutine_C()
    next(C)
    message_A = A.send(None)
    while True:
        message_B = B.send(message_A)
        message_C = C.send(message_B)
        message_A = A.send(message_C)

The problem with this is that it doesn't then seem possible to pass messages in from outside the loop because the while loop just gets stuck doing its thing.

Another way around this is to instantiate coroutine_A with a nested yield expression so that the target can be passed-in after instantiation time:

def coroutine_A():
    while True:
        val = (yield)
        if val is not None:
            coroutine_B_target = val
            while True:
                val = (yield)
                if val is not None:
                    do something to val
                    coroutine_B_target.send(other_val)

A = coroutine_A()
next(A) # prime coroutine
A.send(B) # send in coroutine_B target and step into inner while loop

However, when coroutine_C tries to send a message to coroutine_A I get a ValueError exception: "generator already executing".

So both of these strategies basically lead to:

THE DEEPER ISSUE:

It appears that generators as coroutines can't loop back on themselves, and it seems that the reason for this is that the send call is a 'normal method', so effectively trying to chain a call-stack back on itself, ie doesn't allow recursion / reentry per David Beazley's Generators: The Final Frontier pages 127 to 131.

So its necessary to hand-off the information to a queue system and then dequeue and start a new call. But when I try this, I seem to get stuck with While loops that block messages originating from outside of the loop.

So, long story short, how does one, on one hand, keep the loop cranking over on itself while, on the other hand, remaining open to new messages originating from outside the loop?

Answer 1

也许，看看Stackless Python和Circuits Framework