1

我正在尝试将twisted 与greenlets 一起使用，因此我可以在不使用inlineCallbacks 的情况下以twisted 编写同步外观的代码。

这是我的代码：

import time, functools
from twisted.internet import reactor, threads
from twisted.internet.defer import Deferred
from functools import wraps
import greenlet

def make_async(func):
    @wraps(func)
    def wrapper(*pos, **kwds):
        d = Deferred()

        def greenlet_func():
            try:
                rc = func(*pos, **kwds)
                d.callback(rc)
            except Exception, ex:
                print ex
                d.errback(ex)

        g = greenlet.greenlet(greenlet_func)
        g.switch()

        return d
    return wrapper

def sleep(t):
    print "sleep(): greenelet:", greenlet.getcurrent()
    g = greenlet.getcurrent()
    reactor.callLater(t, g.switch)
    g.parent.switch()

def wait_one(d):
    print "wait_one(): greenelet:", greenlet.getcurrent()
    g = greenlet.getcurrent()
    active = True

    def callback(result):
        if not active:
            g.switch(result)
        else:
            reactor.callLater(0, g.switch, result)

    def errback(failure):
        if not active:
            g.throw(failure)
        else:
            reactor.callLater(0, g.throw, failure)

    d.addCallback(callback)
    d.addErrback(errback)

    active = False
    rc = g.parent.switch()
    return rc

@make_async
def inner():
    print "inner(): greenelet:", greenlet.getcurrent()

    import random, time
    interval = random.random()

    print "Sleeping for %s seconds..." % interval
    sleep(interval)
    print "done"

    return interval

@make_async
def outer():
    print "outer(): greenelet:", greenlet.getcurrent()
    print wait_one(inner())
    print "Here"

reactor.callLater(0, outer)
reactor.run()

有5个主要部分：

  • 一个睡眠功能，它启动一个计时器，然后切换回父 greenlet。当计时器关闭时，它会切换回正在休眠的greenlet。
  • 一个 make_async 装饰器。这需要一些同步的代码并在 greenlet 中运行。IT 还返回一个 deferred，以便调用者可以在代码完成时注册回调。
  • 一个 wait_one 函数，它阻塞 greenlet，直到被等待的延迟解决。
  • 内部函数（当被包装时）返回一个延迟的，随机休眠一段时间，然后将它休眠的时间传递给延迟。
  • 调用 inner() 的外部函数等待它返回，然后打印返回值。

当我运行这段代码时，我得到了这个输出（注意最后两行的错误）：

outer(): greenelet: <greenlet.greenlet object at 0xb729cc5c>
inner(): greenelet: <greenlet.greenlet object at 0xb729ce3c>
Sleeping for 0.545666723422 seconds...
sleep(): greenelet: <greenlet.greenlet object at 0xb729ce3c>
wait_one(): greenelet: <greenlet.greenlet object at 0xb729cc5c>
done
0.545666723422
Here
Exception twisted.python.failure.Failure: <twisted.python.failure.Failure <class 'greenlet.GreenletExit'>> in <greenlet.greenlet object at 0xb729ce3c> ignored
GreenletExit did not kill <greenlet.greenlet object at 0xb729ce3c>

做了一些研究，我发现：

  • 最后一行由 greenlet.c 记录
  • 上一行由 python 本身记录，因为它忽略了del方法中引发的异常。

我在调试它时遇到了真正的麻烦，因为我无法访问GreenletExitortwisted.python.failure.Failure异常来获取它们的堆栈跟踪。

有谁知道我做错了什么，或者我如何调试抛出的异常？

另一个数据点：如果我破解 wait_one() 以立即返回（而不是在传递的延迟上注册任何内容），错误就会消失。：-/

4

2 回答 2

2

像这样重写你的错误回调wait_one：

  def errback(failure):
    ## new code
    if g.dead:
        return
    ##
    if not active:
        g.throw(failure)
    else:
        reactor.callLater(0, g.throw, failure)

如果 greenlet 死了（运行完毕），则没有必要在其中抛出异常。

于 2013-10-26T11:40:52.827 回答
0

mguijarr 的回答解决了这个问题，但我想写下我是如何陷入这种情况的。

我有三个greenlets：

  • {main} 运行反应堆。
  • {outer} 正在运行 external()。
  • {inner} 正在运行 inner()。

当睡眠结束时，{main} 切换到 {inner}，然后切换到 {outer}。然后，Outer 在 {inner} 中返回并引发 GreenletExit。这传播回扭曲。它看到从 callback() 引发的异常，因此调用 errback()。这试图将异常抛出到 {outer} （已经退出），我遇到了错误。

于 2013-10-26T13:01:52.380 回答