• 回调函数的后序发展
  • Deferred
  • 总结
  • 参考

    回调函数的后序发展

    在第六部分我们认识到这样一个情况：回调是Twisted异步编程中的基础。除了与reactor交互外，回调可以安插在任何我们写的Twisted结构内。因此在使用Twisted或其它基于reactor的异步编程体系时，都意味需要将我们的代码组织成一系列由reactor循环可以激活的回调函数链。

    即使一个简单的get_poetry函数都需要回调，两个回调函数中一个用于处理正常结果而另一个用于处理错误。作为一个Twisted程序员，我们必须充分利用这一点。应该花点时间思考一下如何更好地使用回调及使用过程中会遇到什么困难。

    分析下3.1版本中的get_poetry函数：

    1. ...
    2. def got_poem(poem):
    3.     print poem
    4.     reactor.stop()
    5. def poem_failed(err):
    6.     print >>sys.stderr, 'poem download failed'
    7.     print >>sys.stderr, 'I am terribly sorry'
    8.     print >>sys.stderr, 'try again later?'
    9.     reactor.stop()
    11. get_poetry(host, port, got_poem, poem_failed)
    13. reactor.run()

    我们想法很简单：

    1. 如果完成诗歌下载，那么就打印它
    2. 如果没有下载到诗歌，那就打印出错误信息
    3. 上面任何一种情况出现，都要停止程序继续运行

    同步程序中处理上面的情况会采用如下方式：

    1. ...
    2. try:
    3.     poem = get_poetry(host, port) # the synchronous version of get_poetry
    4. except Exception, err:
    5.     print >>sys.stderr, 'poem download failed'
    6.     print >>sys.stderr, 'I am terribly sorry'
    7.     print >>sys.stderr, 'try again later?'
    8.     sys.exit()
    9. else:
    10.     print poem
    11.     sys.exit()

    即callback类似else处理路径，而errback类似except处理路径。这意味着激活errback回调函数类似于同步程序中抛出一个异常，而激活一个callback意味着同步程序中的正常执行路径。
    两个版本有什么不同之外吗？可以明确的是，在同步版本中，Python解释器可以确保只要get_poetry抛出异常(任意类型, 这里特指Exception及其子类)就会执行except块。也就是说只要我们相信Python解释器能够正确的解释执行Python程序，那么就可以相信异常处理块会在恰当的时间点被执行。

    和异步版本不同的是：poem_failed错误回调是由我们自己的代码激活并调用的，即PoetryClientFactory的clientConnectFailed函数。是我们自己而不是Python来确保当出错时错误处理代码能够执行。因此我们必须保证通过调用携带Failure对象的errback来处理任何可能的错误。

    否则，我们的程序就会因为等待一个永远不会出现的回调而止步不前。

    这里显示出了同步与异步版本的又一个不同之处。如果我们在同步版本中没有使用try/except捕获异步，那么Python解释器会为我们捕获然后关掉我们的程序并打印出错误信息。但是如果我们忘记抛出我们的异步异常（在本程序中是在PoetryClientFactory调用errback），我们的程序会一直运行下去，还开心地以为什么事都没有呢。

    显而易见，在异步程序中处理错误是相当重要的，甚至有些严峻。也可以说在异步程序中处理错误信息比处理正常的信息要重要的多，这是因为错误会以多种方式出现，而正确的结果出现的方式是唯一的。当使用Twisted编程时忘记处理异常是一个常犯的错误。

    关于上面同步程序代码的另一个默认的事实是：else与except块两者只能是运行其中一个（假设我们的get_poetry没有在一个无限循环中运行）。Python解释器不会突然决定两者都运行或突发奇想来运行else块27次。对于通过Python来实现那样的动作是不可能的。

    但在异步程序中，我们要负责callback和errback的运行。因此，我们可能就会犯这样的错误：同时调用了callback与errback或激活callback27次。这对于使用get_poetry的用户来说是不幸的。虽然在描述文档中没有明确地说明，像try/except块中的else与except一样，对于每次调用get_poetry时callback与errback只能运行其中一个，不管我们是否成功的下载完诗歌。

    设想一下，我们在调试某个程序时，我们提出了三次诗歌下载请求，但是得到有7次callback被激活和2次errback被激活。可能这时，你会下来检查一下，什么时候get_poetry激活了两次callback并且还抛出一个错误出来。

    从另一个视角来看，两个版本都有代码重复。异步的版本中含有两次reactor.stop，同步版本中含有两次sys.exit调用。我们可以重构同步版本如下：

    1. ...
    2. try:
    3.     poem = get_poetry(host, port) # the synchronous version of get_poetry
    4. except Exception, err:
    5.     print >>sys.stderr, 'poem download failed'
    6.     print >>sys.stderr, 'I am terribly sorry'
    7.     print >>sys.stderr, 'try again later?'
    8. else:
    9.     print poem
    11. sys.exit()

    我们可以以同样的方式来重构异步版本吗？说实话，确实不太可能，因为callback与errback是两个不同的函数。难道要我们回到使用单一回调来实现重构吗？

    好, 下面是我们在讨论使用回调编程时的一些观点：

    1. 激活errback是非常重要的。由于errback的功能与except块相同，因此用户需要确保它们的存在。他们并不是可选项，而是必选项。
    2. 不在错误的时间点激活回调与在正确的时间点激活回调同等重要。典型的用法是，callback与errback是互斥的即只能运行其中一个。
    3. 使用回调函数的代码重构起来有些困难。

    后面的部分我们还会讨论回调，但是到这里已经可以明白为什么Twisted引入了抽象机制(Deferred)来管理回调了。

    Deferred

    由于回调在异步程序中大量被使用，并且正确的使用这一机制需要一些技巧。因此，Twisted开发者设计了一种抽象机制-Deferred-让程序员在使用回调时更加简便。

    一个Deferred有一对回调链，一个是为针对正确结果，另一个针对错误结果。新创建的Deferred的这两条链是空的。我们可以向两条链里分别添加callback与errback。其后，就可以用正确的结果或异常来激活Deferred。激活Deferred意味着以我们添加的顺序激活callback或errback。图12展示了一个拥有callback/errback链的Deferred对象：

    Deferred

    图12 Deferred

    由于defered中不使用reactor，所以使用它并不需要启动事件循环。也许你在Deferred中发现一个setTimeout的函数中使用了reactor。放心，它已经废弃并且会在将来的版本中删掉，我们可以直接无视它。

    下面是我们看看第一个使用deferred的例子twisted-deferred/defer-1.py:

    1. from twisted.internet.defer import Deferred
    3. def got_poem(res):
    4.     print 'Your poem is served:'
    5.     print res
    7. def poem_failed(err):
    8.     print 'No poetry for you.'
    10. d = Deferred()
    12. # add a callback/errback pair to the chain
    13. d.addCallbacks(got_poem, poem_failed)
    15. # fire the chain with a normal result
    16. d.callback('This poem is short.')
    18. print "Finished"

    代码开始创建了一个新deferred，然后使用addCallbacks添加了callback/errback对，然后使用callback函数激活了其正常结果处理回调链。当然了，由于只含有一个回调函数还算不上链，但不要紧，运行它：

    1. Your poem is served:
    2. This poem is short.
    3. Finished

    有几个问题需要注意：

    1. 正如3.1版本中我们使用的callback/errback对，添加到deferred中的回调函数只携带一个参数，正确的结果或出错信息。其实，deferred支持回调函数可以有多个参数，但至少得有一个参数并且第一个只能是正确的结果或错误信息。
    2. 我们向deferred添加的是回调函数对
    3. callbac函数携带仅有的一个参数即正确的结果来激活deferred
    4. 从打印结果顺序可以看出，激活的deferred立即调用了回调。没有任何异步的痕迹。这是因为没有reactor参与导致的。

    好了，让我们来试试另外一种情况，twisted-deferred/defer-2.py激活了错误处理回调：

    1. from twisted.internet.defer import Deferred
    2. from twisted.python.failure import Failure
    4. def got_poem(res):
    5.     print 'Your poem is served:'
    6.     print res
    8. def poem_failed(err):
    9.     print 'No poetry for you.'
    11. d = Deferred()
    13. # add a callback/errback pair to the chain
    14. d.addCallbacks(got_poem, poem_failed)
    16. # fire the chain with an error result
    17. d.errback(Failure(Exception('I have failed.')))
    19. print "Finished"

    运行它打印出的结果为：

    1. No poetry for you.
    2. Finished

    激活errback链就调用errback函数而不是callback，并且传进的参数也是错误信息。正如上面那样，errback在deferred激活就被调用。

    在前面的例子中，我们将一个Failure对象传给了errback。deferred会将一个Exception对象转换成Failure，因此我们可以这样写twisted-deferred/defer-3.py：

    1. from twisted.internet.defer import Deferred
    3. def got_poem(res):
    4.     print 'Your poem is served:'
    5.     print res
    7. def poem_failed(err):
    8.     print err.__class__
    9.     print err
    10.     print 'No poetry for you.'
    12. d = Deferred()
    14. # add a callback/errback pair to the chain
    15. d.addCallbacks(got_poem, poem_failed)
    17. # fire the chain with an error result
    18. d.errback(Exception('I have failed.'))

    运行结果如下：

    1. twisted.python.failure.Failure
    2. [Failure instance: Traceback (failure with no frames): : I have failed.
    3. ]
    4. No poetry for you.

    这意味着在使用deferred时，我们可以正常地使用Exception。其中deferred会为我们完成向Failure的转换。

    下面我们来运行代码twisted-deferred/defer4.py看看会出现什么结果：

    1. from twisted.internet.defer import Deferred
    2. def out(s): print s
    3. d = Deferred()
    4. d.addCallbacks(out, out)
    5. d.callback('First result')
    6. d.callback('Second result')
    7. print 'Finished'

    输出结果：

    1. First result
    2. Traceback (most recent call last):
    3.   ...
    4. twisted.internet.defer.AlreadyCalledError

    很意外吧，也就是说deferred不允许别人激活它两次。这也就解决了上面出现的那个问题：一个激活会导致多个回调同时出现。而deferred设计机制控制住了这种可能，如果你非要在一个deferred上要激活多个回调，那么正如上面那样，会报异常错。

    这里展示了更多的例子:

    1. twisted-deferred/defer-4.py
    2. twisted-deferred/defer-5.py
    3. twisted-deferred/defer-6.py
    4. twisted-deferred/defer-7.py

    那deferred能帮助我们重构异步代码吗？考虑下面twisted-deferred/defer-8.py这个例子：

    1. import sys
    3. from twisted.internet.defer import Deferred
    5. def got_poem(poem):
    6.     print poem
    7.     from twisted.internet import reactor
    8.     reactor.stop()
    10. def poem_failed(err):
    11.     print >>sys.stderr, 'poem download failed'
    12.     print >>sys.stderr, 'I am terribly sorry'
    13.     print >>sys.stderr, 'try again later?'
    14.     from twisted.internet import reactor
    15.     reactor.stop()
    17. d = Deferred()
    19. d.addCallbacks(got_poem, poem_failed)
    21. from twisted.internet import reactor
    23. reactor.callWhenRunning(d.callback, 'Another short poem.')
    25. reactor.run()

    这基本上与我们上面的代码相同，唯一不同的是加进了reactor。我们在启动reactor后调用了callWhenRunning函数来激活deferred。我们利用了callWhenRunning函数可以接收一个额外的参数给回调函数。多数Twisted的API都以这样的方式注册回调函数，包括向deferred添加callback的API。下面我们给deferred回调链添加第二个回调：

    1. import sys
    3. from twisted.internet.defer import Deferred
    5. def got_poem(poem):
    6.     print poem
    8. def poem_failed(err):
    9.     print >>sys.stderr, 'poem download failed'
    10.     print >>sys.stderr, 'I am terribly sorry'
    11.     print >>sys.stderr, 'try again later?'
    13. def poem_done(_):
    14.     from twisted.internet import reactor
    15.     reactor.stop()
    17. d = Deferred()
    19. d.addCallbacks(got_poem, poem_failed)
    20. d.addBoth(poem_done)
    22. from twisted.internet import reactor
    24. reactor.callWhenRunning(d.callback, 'Another short poem.')
    26. reactor.run()

    addBoth函数向callback与errback链中添加了相同的回调函数。在这种方式下，deferred有可能也会执行errback链中的回调。这将在下面的部分讨论，只要记住后面我们还会深入讨论deferred。

    总结

    在这部分我们分析了回调编程与其中潜藏的问题。我们也认识到了deferred是如何帮我们解决这些问题的：

    1. 我们不能忽视errback，在任何异步编程的API中都需要它。Deferred支持errbacks。
    2. 激活回调多次可能会导致很严重的问题。Deferred只能被激活一次，这就类似于同步编程中的try/except的处理方法。
    3. 含有回调的程序在重构时相当困难。有了deferred，我们就通过修改回调链来重构程序。

    关于deferred的故事还没有结束，后面还有大量的细节来讲。但对于使用它来重构我们的客户端已经够用的了，在第八部分将讲述这部分内容。

    参考

    本部分原作参见: dave @ http://krondo.com/?p=1682

    本部分翻译内容参见杨晓伟的博客 http://blog.sina.com.cn/s/blog_704b6af70100q52t.html