基于python生成器封装的协程类

自从python2.2提供了yield关键字之后，python的生成器的很大一部分用途就是可以用来构建协同程序，能够将函数挂起返回中间值并能从上次离开的地方继续执行。python2.5的时候，这种生成器更加接近完全的协程，因为提供了将值和异常传递回到一个继续执行的函数中，当等待生成器的时候，生成器能返回控制。

python提供的生成器设施：

• yield：能够将自己挂起，并提供一个返回值给等待方
• send：唤起一个被挂起的生成器，并能够传递一个参数，可以在生成器中抛出异常
• next：本质上相当于send(none)，对每个生成器的第一次调用必须不能传递参数
• close：主动退出一个生成器
  

python封装

虽然python3提供了asyncio这样的异步io库，而且也有greenlet等其他协程库，但目前的需求并不是实际的网络io并发操作，而是需要模拟状态机的运行，因此使用协程可以很方便的模拟，并加入认为的控制，下面是封装的一个python类。

class coroutine(object):

  """ base class of the general coroutine object """

  state_running = 0
  state_waiting = 1
  state_closing = 2

  def __init__(self):
    self.state = coroutine.state_waiting
    self.started = false
    self.args = none
    self.routine = self._co()

  def _co(self):
    self.ret = none
    while true:
      self.args = yield self.ret
      if not self.started:
        self.started = true
        continue
      else:
        self.state = coroutine.state_running
        self.ret = self.run(self.args)
      if self.state == coroutine.state_closing:
        break
      self.state = coroutine.state_waiting

  def start(self):
    """ start the generator """
    if self.routine is none:
      raise runtimeerror('no task to start running!')
    self.started = true
    self.routine.next()

  def finish(self):
    """ finish the execution of this routine """
    self.state = coroutine.state_closing
    self.routine.close()

  def run(self, args):
    """ the runing method to be executed every once time"""
    raise notimplementederror

  def execute(self, arg_obj):
    """ awake this routine to execute once time """
    return self.routine.send(arg_obj)

基于上述封装，下面实现了一个协同的生产者消费者示例：

class producercoroutine(coroutine):

  """ the producer concrete coroutine """

  def __init__(self, cnsmr):
    if not isinstance(cnsmr, coroutine):
      raise runtimeerror('consumer is not a coroutine object')
    self.consumer = cnsmr
    self.consumer.start()
    super(producercoroutine, self).__init__()

  def run(self, args):
    print 'produce ', args
    ret = self.consumer.execute(args)
    print 'consumer return:', ret

  def __call__(self, args):
    """ custom method for the specific logic """
    self.start()
    while len(args) > 0:
      p = args.pop()
      self.execute(p)
    self.finish()


class consumercoroutine(coroutine):

  """ the consumer concrete coroutine """

  def __init__(self):
    super(consumercoroutine, self).__init__()

  def run(self, args):
    print 'consumer get args: ', args
    return 'hahaha' + repr(args)

运行结果如下：

produce 4
consumer get args: 4
consumer return: hahaha4
produce 3
consumer get args: 3
consumer return: hahaha3
produce 2
consumer get args: 2
consumer return: hahaha2
produce 1
consumer get args: 1
consumer return: hahaha1
produce 0
consumer get args: 0
consumer return: hahaha0

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。