Python 使用生成器代替线程的方法


Posted in Python onAugust 04, 2020

问题

你想使用生成器(协程)替代系统线程来实现并发。这个有时又被称为用户级线程或绿色线程。

解决方案

要使用生成器实现自己的并发,你首先要对生成器函数和 yield 语句有深刻理解。 yield 语句会让一个生成器挂起它的执行,这样就可以编写一个调度器, 将生成器当做某种“任务”并使用任务协作切换来替换它们的执行。 要演示这种思想,考虑下面两个使用简单的 yield 语句的生成器函数:

# Two simple generator functions
def countdown(n):
  while n > 0:
    print('T-minus', n)
    yield
    n -= 1
  print('Blastoff!')

def countup(n):
  x = 0
  while x < n:
    print('Counting up', x)
    yield
    x += 1

这些函数在内部使用yield语句,下面是一个实现了简单任务调度器的代码:

from collections import deque

class TaskScheduler:
  def __init__(self):
    self._task_queue = deque()

  def new_task(self, task):
    '''
    Admit a newly started task to the scheduler
    '''
    self._task_queue.append(task)

  def run(self):
    '''
    Run until there are no more tasks
    '''
    while self._task_queue:
      task = self._task_queue.popleft()
      try:
        # Run until the next yield statement
        next(task)
        self._task_queue.append(task)
      except StopIteration:
        # Generator is no longer executing
        pass

# Example use
sched = TaskScheduler()
sched.new_task(countdown(10))
sched.new_task(countdown(5))
sched.new_task(countup(15))
sched.run()

TaskScheduler 类在一个循环中运行生成器集合——每个都运行到碰到yield语句为止。 运行这个例子,输出如下:

T-minus 10
T-minus 5
Counting up 0
T-minus 9
T-minus 4
Counting up 1
T-minus 8
T-minus 3
Counting up 2
T-minus 7
T-minus 2
...

到此为止,我们实际上已经实现了一个“操作系统”的最小核心部分。 生成器函数就是任务,而yield语句是任务挂起的信号。 调度器循环检查任务列表直到没有任务要执行为止。

实际上,你可能想要使用生成器来实现简单的并发。 那么,在实现actor或网络服务器的时候你可以使用生成器来替代线程的使用。

下面的代码演示了使用生成器来实现一个不依赖线程的actor:

from collections import deque

class ActorScheduler:
  def __init__(self):
    self._actors = {}     # Mapping of names to actors
    self._msg_queue = deque()  # Message queue

  def new_actor(self, name, actor):
    '''
    Admit a newly started actor to the scheduler and give it a name
    '''
    self._msg_queue.append((actor,None))
    self._actors[name] = actor

  def send(self, name, msg):
    '''
    Send a message to a named actor
    '''
    actor = self._actors.get(name)
    if actor:
      self._msg_queue.append((actor,msg))

  def run(self):
    '''
    Run as long as there are pending messages.
    '''
    while self._msg_queue:
      actor, msg = self._msg_queue.popleft()
      try:
         actor.send(msg)
      except StopIteration:
         pass

# Example use
if __name__ == '__main__':
  def printer():
    while True:
      msg = yield
      print('Got:', msg)

  def counter(sched):
    while True:
      # Receive the current count
      n = yield
      if n == 0:
        break
      # Send to the printer task
      sched.send('printer', n)
      # Send the next count to the counter task (recursive)
      sched.send('counter', n-1)

  sched = ActorScheduler()
  # Create the initial actors
  sched.new_actor('printer', printer())
  sched.new_actor('counter', counter(sched))

  # Send an initial message to the counter to initiate
  sched.send('counter', 10000)
  sched.run()

完全弄懂这段代码需要更深入的学习,但是关键点在于收集消息的队列。 本质上,调度器在有需要发送的消息时会一直运行着。 计数生成器会给自己发送消息并在一个递归循环中结束。

下面是一个更加高级的例子,演示了使用生成器来实现一个并发网络应用程序:

from collections import deque
from select import select

# This class represents a generic yield event in the scheduler
class YieldEvent:
  def handle_yield(self, sched, task):
    pass

  def handle_resume(self, sched, task):
    pass

# Task Scheduler
class Scheduler:
  def __init__(self):
    self._numtasks = 0    # Total num of tasks
    self._ready = deque()  # Tasks ready to run
    self._read_waiting = {} # Tasks waiting to read
    self._write_waiting = {} # Tasks waiting to write

  # Poll for I/O events and restart waiting tasks
  def _iopoll(self):
    rset,wset,eset = select(self._read_waiting,
                self._write_waiting,[])
    for r in rset:
      evt, task = self._read_waiting.pop(r)
      evt.handle_resume(self, task)
    for w in wset:
      evt, task = self._write_waiting.pop(w)
      evt.handle_resume(self, task)

  def new(self,task):
    '''
    Add a newly started task to the scheduler
    '''
    self._ready.append((task, None))
    self._numtasks += 1

  def add_ready(self, task, msg=None):
    '''
    Append an already started task to the ready queue.
    msg is what to send into the task when it resumes.
    '''
    self._ready.append((task, msg))

  # Add a task to the reading set
  def _read_wait(self, fileno, evt, task):
    self._read_waiting[fileno] = (evt, task)

  # Add a task to the write set
  def _write_wait(self, fileno, evt, task):
    self._write_waiting[fileno] = (evt, task)

  def run(self):
    '''
    Run the task scheduler until there are no tasks
    '''
    while self._numtasks:
       if not self._ready:
         self._iopoll()
       task, msg = self._ready.popleft()
       try:
         # Run the coroutine to the next yield
         r = task.send(msg)
         if isinstance(r, YieldEvent):
           r.handle_yield(self, task)
         else:
           raise RuntimeError('unrecognized yield event')
       except StopIteration:
         self._numtasks -= 1

# Example implementation of coroutine-based socket I/O
class ReadSocket(YieldEvent):
  def __init__(self, sock, nbytes):
    self.sock = sock
    self.nbytes = nbytes
  def handle_yield(self, sched, task):
    sched._read_wait(self.sock.fileno(), self, task)
  def handle_resume(self, sched, task):
    data = self.sock.recv(self.nbytes)
    sched.add_ready(task, data)

class WriteSocket(YieldEvent):
  def __init__(self, sock, data):
    self.sock = sock
    self.data = data

  def handle_yield(self, sched, task):
    sched._write_wait(self.sock.fileno(), self, task)

  def handle_resume(self, sched, task):
    nsent = self.sock.send(self.data)
    sched.add_ready(task, nsent)

class AcceptSocket(YieldEvent):
  def __init__(self, sock):
    self.sock = sock

  def handle_yield(self, sched, task):
    sched._read_wait(self.sock.fileno(), self, task)

  def handle_resume(self, sched, task):
    r = self.sock.accept()
    sched.add_ready(task, r)

# Wrapper around a socket object for use with yield
class Socket(object):
  def __init__(self, sock):
    self._sock = sock

  def recv(self, maxbytes):
    return ReadSocket(self._sock, maxbytes)

  def send(self, data):
    return WriteSocket(self._sock, data)

  def accept(self):
    return AcceptSocket(self._sock)

  def __getattr__(self, name):
    return getattr(self._sock, name)

if __name__ == '__main__':
  from socket import socket, AF_INET, SOCK_STREAM
  import time

  # Example of a function involving generators. This should
  # be called using line = yield from readline(sock)
  def readline(sock):
    chars = []
    while True:
      c = yield sock.recv(1)
      if not c:
        break
      chars.append(c)
      if c == b'\n':
        break
    return b''.join(chars)

  # Echo server using generators
  class EchoServer:
    def __init__(self,addr,sched):
      self.sched = sched
      sched.new(self.server_loop(addr))

    def server_loop(self,addr):
      s = Socket(socket(AF_INET,SOCK_STREAM))

      s.bind(addr)
      s.listen(5)
      while True:
        c,a = yield s.accept()
        print('Got connection from ', a)
        self.sched.new(self.client_handler(Socket(c)))

    def client_handler(self,client):
      while True:
        line = yield from readline(client)
        if not line:
          break
        line = b'GOT:' + line
        while line:
          nsent = yield client.send(line)
          line = line[nsent:]
      client.close()
      print('Client closed')

  sched = Scheduler()
  EchoServer(('',16000),sched)
  sched.run()

这段代码有点复杂。不过,它实现了一个小型的操作系统。 有一个就绪的任务队列,并且还有因I/O休眠的任务等待区域。 还有很多调度器负责在就绪队列和I/O等待区域之间移动任务。

讨论

在构建基于生成器的并发框架时,通常会使用更常见的yield形式:

def some_generator():
  ...
  result = yield data
  ...

使用这种形式的yield语句的函数通常被称为“协程”。 通过调度器,yield语句在一个循环中被处理,如下:

f = some_generator()

# Initial result. Is None to start since nothing has been computed
result = None
while True:
  try:
    data = f.send(result)
    result = ... do some calculation ...
  except StopIteration:
    break

这里的逻辑稍微有点复杂。不过,被传给 send() 的值定义了在yield语句醒来时的返回值。 因此,如果一个yield准备在对之前yield数据的回应中返回结果时,会在下一次 send() 操作返回。 如果一个生成器函数刚开始运行,发送一个None值会让它排在第一个yield语句前面。

除了发送值外,还可以在一个生成器上面执行一个 close() 方法。 它会导致在执行yield语句时抛出一个 GeneratorExit 异常,从而终止执行。 如果进一步设计,一个生成器可以捕获这个异常并执行清理操作。 同样还可以使用生成器的 throw() 方法在yield语句执行时生成一个任意的执行指令。 一个任务调度器可利用它来在运行的生成器中处理错误。

最后一个例子中使用的 yield from 语句被用来实现协程,可以被其它生成器作为子程序或过程来调用。 本质上就是将控制权透明的传输给新的函数。 不像普通的生成器,一个使用 yield from 被调用的函数可以返回一个作为 yield from 语句结果的值。 关于 yield from 的更多信息可以在 PEP 380 中找到。

最后,如果使用生成器编程,要提醒你的是它还是有很多缺点的。 特别是,你得不到任何线程可以提供的好处。例如,如果你执行CPU依赖或I/O阻塞程序, 它会将整个任务挂起直到操作完成。为了解决这个问题, 你只能选择将操作委派给另外一个可以独立运行的线程或进程。 另外一个限制是大部分Python库并不能很好的兼容基于生成器的线程。 如果你选择这个方案,你会发现你需要自己改写很多标准库函数。 作为本节提到的协程和相关技术的一个基础背景,可以查看 PEP 342 和 “协程和并发的一门有趣课程”

PEP 3156 同样有一个关于使用协程的异步I/O模型。 特别的,你不可能自己去实现一个底层的协程调度器。 不过,关于协程的思想是很多流行库的基础, 包括 gevent, greenlet, Stackless Python 以及其他类似工程。

以上就是Python 使用生成器代替线程的方法的详细内容,更多关于Python 生成器代替线程的资料请关注三水点靠木其它相关文章!

Python 相关文章推荐
Python操作MySQL简单实现方法
Jan 26 Python
调试Python程序代码的几种方法总结
Apr 28 Python
python3编码问题汇总
Sep 06 Python
Python常见加密模块用法分析【MD5,sha,crypt模块】
May 24 Python
python正则表达式面试题解答
Apr 28 Python
python中数据爬虫requests库使用方法详解
Feb 11 Python
python文件操作之批量修改文件后缀名的方法
Aug 10 Python
python使用 zip 同时迭代多个序列示例
Jul 06 Python
使用Python的Turtle绘制哆啦A梦实例
Nov 21 Python
pip install 使用国内镜像的方法示例
Apr 03 Python
Python使用jupyter notebook查看ipynb文件过程解析
Jun 02 Python
Python自动化测试PO模型封装过程详解
Jun 22 Python
详解Tensorflow不同版本要求与CUDA及CUDNN版本对应关系
Aug 04 #Python
python读取xml文件方法解析
Aug 04 #Python
如何利用python进行时间序列分析
Aug 04 #Python
通过实例简单了解Python sys.argv[]使用方法
Aug 04 #Python
哪种Python框架适合你?简单介绍几种主流Python框架
Aug 04 #Python
python logging 重复写日志问题解决办法详解
Aug 04 #Python
Windows下Sqlmap环境安装教程详解
Aug 04 #Python
You might like
消息持续发送的完整例子
2006/10/09 PHP
从C/C++迁移到PHP——判断字符类型的函数
2006/10/09 PHP
选择PHP作为网站开发语言的原因分享
2012/01/03 PHP
学习使用curl采集curl使用方法
2012/01/11 PHP
PHP5.4中json_encode中文转码的变化小结
2013/01/30 PHP
PHP中实现Bloom Filter算法
2015/03/30 PHP
如何修改Laravel中url()函数生成URL的根地址
2017/08/11 PHP
php使用imagecopymerge()函数创建半透明水印
2018/01/25 PHP
javascript对talbe进行动态添加、删除、验证实现代码
2012/03/29 Javascript
浅谈JavaScript的事件
2015/02/27 Javascript
JavaScript使用push方法添加一个元素到数组末尾用法实例
2015/04/06 Javascript
javascript跨域的方法汇总
2015/10/23 Javascript
jquery+php实现滚动的数字特效
2015/11/29 Javascript
JS+CSS实现闪烁字体效果代码
2016/04/05 Javascript
AngularJS实现的回到顶部指令功能实例
2017/05/17 Javascript
JS如何设置元素样式的方法示例
2017/08/28 Javascript
JavaScript登录验证基础教程
2017/11/01 Javascript
浅谈Node模块系统及其模式
2017/11/17 Javascript
详解ajax的data参数错误导致页面崩溃
2018/04/30 Javascript
js常用方法、检查是否有特殊字符串、倒序截取字符串操作完整示例
2020/01/26 Javascript
在vue-cli3.0 中使用预处理器 (Sass/Less/Stylus) 配置全局变量操作
2020/08/10 Javascript
JavaScript 如何计算文本的行数的实现
2020/09/14 Javascript
Python环境下搭建属于自己的pip源的教程
2016/05/05 Python
基于Linux系统中python matplotlib画图的中文显示问题的解决方法
2017/06/15 Python
Pycharm技巧之代码跳转该如何回退
2017/07/16 Python
python遍历序列enumerate函数浅析
2017/10/17 Python
对python 多个分隔符split 的实例详解
2018/12/20 Python
利用Python的sympy包求解一元三次方程示例
2019/11/22 Python
迪卡侬英国官网:Decathlon英国
2017/04/08 全球购物
什么是smarty? Smarty的优点是什么?
2013/08/11 面试题
测绘工程个人的自我评价
2013/11/10 职场文书
工程造价专业大学生职业生涯规划书
2014/01/18 职场文书
2016感恩父亲节主题广播稿
2015/12/18 职场文书
Java实现二维数组和稀疏数组之间的转换
2021/06/27 Java/Android
Pandas 稀疏数据结构的实现
2021/07/25 Python
利用Python实时获取steam特惠游戏数据
2022/06/25 Python