Python 中的协程，到底是怎么回事？（python能做什么）

在io比较多的场景中， ​​Async​​​语法编写的程序会以更少的时间， 更少的资源来完成相同的任务， 这篇文章则是介绍了​​Python​​​的​​Async​​语法的协程是如何实现的。内容较长，喜欢记得收藏、关注、点赞。

1.传统的Sync语法请求例子

还是一样， 在了解​​Async​​​语法的实现之前， 先从一个​​Sync​​的语法例子开始， 现在假设有一个HTTP请求， 这个程序会通过这个请求获取对应的响应内容， 并打印出来, 代码如下：

import socketdef request(host: str) -> None: """模拟请求并打印响应体""" url: str = f" sock: socket.SocketType = socket.socket() sock.connect((host, 80)) sock.send(f"GET {url} HTTP/1.0\r\nHost: {host}\r\n\r\n".encode("ascii")) response_bytes: bytes = b"" chunk: bytes = sock.recv(4096) while chunk: response_bytes += chunk chunk = sock.recv(4096) print("\n".join([i for i in response_bytes.decode().split("\r\n")]))if __name__ == "__main__": request("so1n.me")

运行程序， 程序能够正常输出, 上部分打印了对应的HTTP响应Header, 下部分打印了HTTP响应体, , 可以看到服务端叫我们以输出结果如下：

HTTP/1.1 301 Moved PermanentlyServer: GitHub.comContent-Type: text/htmlLocation: A744:3871:4136AF:48BD9F:6188DB50Content-Length: 162Accept-Ranges: bytesDate: Mon, 08 Nov 2021 08:11:37 GMTVia: 1.1 varnishAge: 104Connection: closeX-Served-By: cache-qpg1272-QPGX-Cache: HITX-Cache-Hits: 2X-Timer: S1636359097.026094,VS0,VE0Vary: Accept-EncodingX-Fastly-Request-ID: 22fa337f777553d33503cee5282598c6a293fb5e

不过这里并不是想说HTTP请求是如何实现的， 具体我也不太了解， 在这个代码中， socket的默认调用是阻塞的， 当线程调用​​connect​​​或者​​recv​​​时(​​send​​​是不用等待的， 但在高并发下需要先等待​​drain​​​后才可以​​send​​​, 小demo不需要用到​​drain​​方法)， 程序将会暂停直到操作完成。当一次要下载很多网页的话， 这将会如上篇文章所说的一样， 大部分的等待时间都花在io上面， cpu却一直空闲时， 而使用线程池虽然可以解决这个问题， 但是开销是很大的， 同时操作系统往往会限制一个进程，用户或者机器可以使用的线程数， 而协程却没有这些限制， 占用的资源少， 也没有系统限制瓶颈。

2.异步的请求

异步可以让一个单独的线程处理并发的操作， 不过在上面已经说过了， socket是默认阻塞的， 所以需要把socket设置为非阻塞的, socket提供了​​setblocking​​​这个方法供开发者选择是否阻塞， 在设置了非阻塞后， ​​connect​​​和​​recv​​方法也要进行更改。

由于没有了阻塞， 程序在调用了​​connect​​​后会马上返回， 只不过​​Python​​​的底层是​​C​​​, 这段代码在​​C​​中调用非阻塞的socket.connect后会抛出一个异常， 我们需要捕获它， 就像这样：

import socketsock: socket.SocketType = socket.socket()sock.setblocking(Flase)try: sock.connect(("so1n.me", 80))except BlockingIOError: pass

经过一顿操作后， 就开始申请建立连接了， 但是我们还不知道连接啥时候完成建立， 由于连接没建立时调用​​send​​​会报错， 所以可以一直轮询调用​​send​​直到没报错就认为是成功（真实代码需要加超时）：

while True: try: sock.send(request) break except OSError as e: pass

但是这样让CPU空转太浪费性能了， 而且期间还不能做别的事情， 就像我们点外卖后一直打电话过去问饭菜做好了没有， 十分浪费电话费用， 要是饭菜做完了就打电话告诉我们， 那就只产生了一笔费用， 非常的省钱（正常情况下也是这样子）。这时就需要事件循环登场了，在类UNIX中， 有一个叫​​select​​​的功能， 它可以等待事件发生后再调用监听的函数， 不过一开始的实现性能不是很好， 在​​Linux​​​上被​​epoll​​​取代， 不过接口是类似的， 所在在​​Python​​​中把这几个不同的事件循环都封装在​​selectors​​​库中， 同时可以通过​​DefaultSelector​​​从系统中挑出最好的类​​select​​​函数。这里先暂时不说事件循环的原理， 事件循环最主要的是他名字的两部分， 一个是事件， 一个是循环， 在​​Python​​中， 可以通过如下方法把事件注册到事件循环中：

def demo(): passselector.register(fd, EVENT_WRITE, demo)

这样这个事件循环就会监听对应的文件描述符fd, 当这个文件描述符触发写入事件(EVENT_WRITE)时，事件循环就会告诉我们可以去调用注册的函数​​demo​​。不过如果把上面的代码都改为这种方法去运行的话就会发现， 程序好像没跑就结束了， 但程序其实是有跑的， 只不过他们是完成的了注册， 然后就等待开发者接收事件循环的事件进行下一步的操作， 所以我们只需要在代码的最后面写上如下代码:

while True: for key, mask in selector.select(): key.data()

这样程序就会一直运行, 当捕获到事件的时候， 就会通过for循环告诉我们， 其中​​key.data​​是我们注册的回调函数， 当事件发生时， 就会通知我们， 我们可以通过拿到回调函数然后就运行, 了解完毕后， 我们可以来编写我们的第一个并发程序， 他实现了一个简单的I/O复用的小逻辑, 代码和注释如下：

import socketfrom selectors import DefaultSelector, EVENT_READ, EVENT_WRITE# 选择事件循环selector: DefaultSelector = DefaultSelector()# 用于判断是否有事件在运行running_cnt: int = 0def request(host: str) -> None: """模拟请求并打印响应体""" # 告诉主函数， 自己的事件还在运行 global running_cnt running_cnt += 1 # 初始化socket url: str = f" sock: socket.SocketType = socket.socket() sock.setblocking(False) try: sock.connect((host, 80)) except BlockingIOError: pass response_bytes: bytes = b"" def read_response() -> None: """接收响应参数， 并判断请求是否结束""" nonlocal response_bytes chunk: bytes = sock.recv(4096) print(f"recv {host} body success") if chunk: response_bytes += chunk else: # 没有数据代表请求结束了， 注销监听 selector.unregister(sock.fileno()) global running_cnt running_cnt -= 1 def connected() -> None: """socket建立连接时的回调""" # 取消监听 selector.unregister(sock.fileno()) print(f"{host} connect success") # 发送请求， 并监听读事件， 以及注册对应的接收响应函数 sock.send(f"GET {url} HTTP/1.0\r\nHost: {host}\r\n\r\n".encode("ascii")) selector.register(sock.fileno(), EVENT_READ, read_response) selector.register(sock.fileno(), EVENT_WRITE, connected)if __name__ == "__main__": # 同时多个请求 request("so1n.me") request("github.com") request("google.com") request("baidu.com") # 监听是否有事件在运行 while running_cnt > 0: # 等待事件循环通知事件是否已经完成 for key, mask in selector.select(): key.data()

这段代码接近同时注册了4个请求并注册建立连接回调， 然后就进入事件循环逻辑， 也就是把控制权交给事件循环， 直到事件循环告诉程序说收到了socket建立的通知， 程序就会取消注册的回调然后发送请求， 并注册一个读的事件回调， 然后又把控制权交给事件循环， 直到收到了响应的结果才进入处理响应结果函数并且只有收完所有响应结果才会退出程序。下面是我其中的一次执行结果

so1n.me connect successgithub.com connect successgoogle.com connect successrecv google.com body successrecv google.com body successbaidu.com connect successrecv github.com body successrecv github.com body successrecv baidu.com body successrecv baidu.com body successrecv so1n.me body successrecv so1n.me body success

可以看到他们的执行顺序是随机的， 不是严格的按照​​so1n.me​​​, ​​github.com​​​, ​​google.com​​​, ​​baidu.com​​​顺序执行， 同时他们执行速度很快， 这个程序的耗时约等于响应时长最长的函数耗时。但是可以看出， 这个程序里面出现了两个回调， 回调会让代码变得非常的奇怪, 降低可读性， 也容易造成回调地狱， 而且当回调发生报错的时候， 我们是很难知道这是由于什么导致的错误， 因为它的上下文丢失了， 这样子排查问题十分的困惑。作为程序员， 一般都不止满足于速度快的代码， 真正想要的是又快， 又能像​​Sync​​的代码一样简单, 可读性强, 也能容易排查问题的代码, 这种组合形式的代码的设计模式就叫协程。

协程出现得很早， 它不像线程一样， 被系统调度， 而是能自主的暂停， 并等待事件循环通知恢复。由于协程是软件层面实现的， 所以它的实现方式有很多种， 这里要说的是基于生成器的协程， 因为生成器跟协程一样， 都有暂停让步和恢复的方法(还可以通过​​throw​​​来抛错）， 同时它跟​​Async​​​语法的协程很像， 通过了解基于生成器的协程， 可以了解​​Async​​的协程是如何实现的。

3.基于生成器的协程

3.1生成器

在了解基于生成器的协程之前， 需要先了解下生成器， ​​Python​​​的生成器函数与普通的函数会有一些不同, 只有普通函数中带有关键字​​yield​​， 那么它就是生成器函数， 具体有什么不同可以通过他们的字节码来了解：

In [1]: import dis# 普通函数In [2]: def aaa(): passIn [3]: dis.dis(aaa) 1 0 LOAD_CONST 0 (None) 2 RETURN_VALUE# 普通函数调用函数In [4]: def bbb(): ...: aaa() ...:In [5]: dis.dis(bbb) 2 0 LOAD_GLOBAL 0 (aaa) 2 CALL_FUNCTION 0 4 POP_TOP 6 LOAD_CONST 0 (None) 8 RETURN_VALUE# 普通生成器函数In [6]: def ccc(): yieldIn [7]: dis.dis(ccc) 1 0 LOAD_CONST 0 (None) 2 YIELD_VALUE 4 POP_TOP 6 LOAD_CONST 0 (None) 8 RETURN_VALUE

上面分别是普通函数， 普通函数调用函数和普通生成器函数的字节码， 从字节码可以看出来， 最简单的函数只需要​​LOAD_CONST​​​来加载变量None压入自己的栈， 然后通过​​RETURN_VALUE​​​来返回值， 而有函数调用的普通函数则先加载变量， 把全局变量的函数​​aaa​​​加载到自己的栈里面， 然后通过​​CALL_FUNCTION​​​来调用函数， 最后通过​​POP_TOP​​​把函数的返回值从栈里抛出来， 再把通过​​LOAD_CONST​​​把None压入自己的栈， 最后返回值。而生成器函数则不一样， 它会先通过​​LOAD_CONST​​​来加载变量None压入自己的栈， 然后通过​​YIELD_VALUE​​​返回值， 接着通过​​POP_TOP​​​弹出刚才的栈并重新把变量None压入自己的栈， 最后通过​​RETURN_VALUE​​​来返回值。从字节码来分析可以很清楚的看到， 生成器能够在​​yield​​区分两个栈帧, 一个函数调用可以分为多次返回， 很符合协程多次等待的特点。

接着来看看生成器的一个使用, 这个生成器会有两次​​yield​​​调用, 并在最后返回字符串​​'None'​​， 代码如下：

In [8]: def demo(): ...: a = 1 ...: b = 2 ...: print('aaa', locals()) ...: yield 1 ...: print('bbb', locals()) ...: yield 2 ...: return 'None' ...: In [9]: demo_gen = demo()In [10]: demo_gen.send(None)aaa {'a': 1, 'b': 2}Out[10]: 1In [11]: demo_gen.send(None)bbb {'a': 1, 'b': 2}Out[11]: 2In [12]: demo_gen.send(None)---------------------------------------------------------------------------StopIteration Traceback (most recent call last) in ----> 1 demo_gen.send(None)StopIteration: None

这段代码首先通过函数调用生成一个​​demo_gen​​​的生成器对象, 然后第一次​​send​​​调用时返回值1， 第二次​​send​​​调用时返回值2， 第三次​​send​​​调用则抛出​​StopIteration​​​异常， 异常提示为​​None​​​, 同时可以看到第一次打印​​aaa​​​和第二次打印​​bbb​​时， 他们都能打印到当前的函数局部变量， 可以发现在即使在不同的栈帧中， 他们读取到当前的局部函数内的局部变量是一致的， 这意味着如果使用生成器来模拟协程时， 它还是会一直读取到当前上下文的， 非常的完美。

此外， ​​Python​​​还支持通过​​yield from​​语法来返回一个生成器, 代码如下:

In [1]: def demo_gen_1(): ...: for i in range(3): ...: yield i ...:In [2]: def demo_gen_2(): ...: yield from demo_gen_1() ...:In [3]: demo_gen_obj = demo_gen_2()In [4]: demo_gen_obj.send(None) Out[4]: 0In [5]: demo_gen_obj.send(None)Out[5]: 1In [6]: demo_gen_obj.send(None)Out[6]: 2In [7]: demo_gen_obj.send(None) ---------------------------------------------------------------------------StopIteration Traceback (most recent call last) in ----> 1 demo_gen_obj.send(None)StopIteration:

通过​​yield from​​​就可以很方便的支持生成器调用， 假如把每个生成器函数都当做一个协程， 那通过​​yield from​​​就可以很方便的实现协程间的调用， 此外生成器的抛出异常后的提醒非常人性化， 也支持​​throw​​​来抛出异常， 这样我们就可以实现在协程运行时设置异常， 比如​​Cancel​​，演示代码如下:

In [1]: def demo_exc(): ...: yield 1 ...: raise RuntimeError() ...:In [2]: def demo_exc_1(): ...: for i in range(3): ...: yield i ...:In [3]: demo_exc_gen = demo_exc()In [4]: demo_exc_gen.send(None) Out[4]: 1In [5]: demo_exc_gen.send(None) ---------------------------------------------------------------------------RuntimeError Traceback (most recent call last) in ----> 1 demo_exc_gen.send(None) in demo_exc() 1 def demo_exc(): 2 yield 1----> 3 raise RuntimeError() 4 RuntimeError: In [6]: demo_exc_gen_1 = demo_exc_1()In [7]: demo_exc_gen_1.send(None) Out[7]: 0In [8]: demo_exc_gen_1.send(None) Out[8]: 1In [9]: demo_exc_gen_1.throw(RuntimeError) ---------------------------------------------------------------------------RuntimeError Traceback (most recent call last) in ----> 1 demo_exc_gen_1.throw(RuntimeError) in demo_exc_1() 1 def demo_exc_1(): 2 for i in range(3):----> 3 yield i 4 RuntimeError:

从中可以看到在运行中抛出异常时， 会有一个非常清楚的抛错， 可以明显看出错误堆栈， 同时​​throw​​​指定异常后， 会在下一处​​yield​​​抛出异常(所以协程调用​​Cancel​​后不会马上取消， 而是下一次调用的时候才被取消)。

3.2用生成器实现协程

我们已经简单的了解到了生成器是非常的贴合协程的编程模型， 同时也知道哪些生成器API是我们需要的API， 接下来可以模仿​​Asyncio​​的接口来实现一个简单的协程。

首先是在​​Asyncio​​​中有一个封装叫​​Feature​​​, 它用来表示协程正在等待将来时的结果, 以下是我根据​​asyncio.Feature​​​封装的一个简单的​​Feature​​​, 它的API没有​​asyncio.Feature​​全, 代码和注释如下:

class Status: """用于判断Future状态""" pending: int = 1 finished: int = 2 cancelled: int = 3class Future(object): def __init__(self) -> None: """初始化时， Feature处理pending状态， 等待set result""" self.status: int = Status.pending self._result: Any = None self._exception: Optional[Exception] = None self._callbacks: List[Callable[['Future'], None]] = [] def add_done_callback(self, fn: [['Future'], None]Callable) -> None: """添加完成时的回调""" self._callbacks.append(fn) def cancel(self): """取消当前的Feature""" if self.status != Status.pending: return False self.status = Status.cancelled for fn in self._callbacks: fn(self) return True def set_exception(self, exc: Exception) -> None: """设置异常""" if self.status != Status.pending: raise RuntimeError("Can not set exc") self._exception = exc self.status = Status.finished def set_result(self, result: Any) -> None: """设置结果""" if self.status != Status.pending: raise RuntimeError("Can not set result") self.status = Status.finished self._result = result for fn in self._callbacks: fn(self) def result(self): """获取结果""" if self.status == Status.cancelled: raise asyncio.CancelledError elif self.status != Status.finished: raise RuntimeError("Result is not read") elif self._exception is not None: raise self._exception return self._result def __iter__(self): """通过生成器来模拟协程， 当收到结果通知时， 会返回结果""" if self.status == Status.pending: yield self return self.result()

在理解​​Future​​​时， 可以把它假想为一个状态机， 在启动初始化的时候是​​peding​​​状态， 在运行的时候我们可以切换它的状态, 并且通过​​__iter__​​​方法来支持调用者使用​​yield from Future()​​​来等待​​Future​​本身， 直到收到了事件通知时， 可以得到结果。

但是可以发现这个​​Future​​​是无法自我驱动, 调用了​​__iter__​​​的程序不知道何时被调用了​​set_result​​​， 在​​Asyncio​​​中是通过一个叫​​Task​​​的类来驱动​​Future​​, 它将一个协程的执行过程安排好， 并负责在事件循环中执行该协程。它主要有两个方法:

1.初始化时， 会先通过​​send​​方法激活生成器2.后续被调度后马上安排下一次等待， 除非抛出​​StopIteration​​异常

还有一个支持取消运行托管协程的方法(在原代码中， ​​Task​​​是继承于​​Future​​​, 所以​​Future​​有的它都有), 经过简化后的代码如下：

class Task: def __init__(self, coro: Generator) -> None: # 初始化状态 self.cancelled: bool = False self.coro: Generator = coro # 预激一个普通的future f: Future = Future() f.set_result(None) self.step(f) def cancel(self) -> None: """用于取消托管的coro""" self.coro.throw(asyncio.CancelledError) def step(self, f: Future) -> None: """用于调用coro的下一步, 从第一次激活开始， 每次都添加完成时的回调， 直到遇到取消或者StopIteration异常""" try: _future = self.coro.send(f.result()) except asyncio.CancelledError: self.cancelled = True return except StopIteration: return _future.add_done_callback(self.step)

这样​​Future​​​和​​Task​​就封装好了， 可以简单的试一试效果如何:

In [2]:def wait_future(f: Future, flag_int: int) -> Generator[Future, None, None]: ...: result = yield from f ...: print(flag_int, result) ...: ...:future: Future = Future() ...:for i in range(3): ...: coro = wait_future(future, i) ...: # 托管wait_future这个协程， 里面的Future也会通过yield from被托管 ...: Task(coro) ...: ...:print('ready') ...:future.set_result('ok') ...: ...:future = Future() ...:Task(wait_future(future, 3)).cancel() ...: ready0 ok1 ok2 ok---------------------------------------------------------------------------CancelledError Traceback (most recent call last) in 12 13 future = Future()---> 14 Task(wait_future(future, 3)).cancel() in cancel(self) 81 82 def cancel(self) -> None:---> 83 self.coro.throw(asyncio.CancelledError) 84 85 def step(self, f: Future) -> None: in wait_future(f, flag_int) 1 def wait_future(f: Future, flag_int: int) -> Generator[Future, None, None]:----> 2 result = yield from f 3 print(flag_int, result) 4 5 future: Future = Future() in __iter__(self) 68 """通过生成器来模拟协程， 当收到结果通知时， 会返回结果""" 69 if self.status == Status.pending:---> 70 yield self 71 return self.result() 72 CancelledError:

这段程序会先初始化​​Future​​​, 并把​​Future​​​传给​​wait_future​​​并生成生成器, 再交由给​​Task​​​托管， 预激, 由于​​Future​​​是在生成器函数​​wait_future​​​中通过​​yield from​​​与函数绑定的， 真正被预激的其实是​​Future​​​的​​__iter__​​​方法中的​​yield self​​​, 此时代码逻辑会暂停在​​yield self​​​并返回。在全部预激后， 通过调用​​Future​​​的​​set_result​​​方法， 使​​Future​​​变为结束状态， 由于​​set_result​​​会执行注册的回调， 这时它就会执行托管它的​​Task​​​的​​step​​​方法中的​​send​​​方法, 代码逻辑回到​​Future​​​的​​__iter__​​​方法中的​​yield self​​​， 并继续往下走， 然后遇到​​return​​​返回结果, 并继续走下去, 从输出可以发现程序封装完成且打印了​​ready​​​后， 会依次打印对应的返回结果， 而在最后一个的测试​​cancel​​​方法中可以看到，​​Future​​抛出异常了， 同时这些异常很容易看懂， 能够追随到调用的地方。

现在​​Future​​​和​​Task​​正常运行了， 可以跟我们一开始执行的程序进行整合, 代码如下：

class HttpRequest(object): def __init__(self, host: str): """初始化变量和sock""" self._host: str = host global running_cnt running_cnt += 1 self.url: str = f" self.sock: socket.SocketType = socket.socket() self.sock.setblocking(False) try: self.sock.connect((host, 80)) except BlockingIOError: pass def read(self) -> Generator[Future, None, bytes]: """从socket获取响应数据， 并set到Future中， 并通过Future.__iter__方法或得到数据并通过变量chunk_future返回""" f: Future = Future() selector.register(self.sock.fileno(), EVENT_READ, lambda: f.set_result(self.sock.recv(4096))) chunk_future = yield from f selector.unregister(self.sock.fileno()) return chunk_future # type: ignore def read_response(self) -> Generator[Future, None, bytes]: """接收响应参数， 并判断请求是否结束""" response_bytes: bytes = b"" chunk = yield from self.read() while chunk: response_bytes += chunk chunk = yield from self.read() return response_bytes def connected(self) -> Generator[Future, None, None]: """socket建立连接时的回调""" # 取消监听 f: Future = Future() selector.register(self.sock.fileno(), EVENT_WRITE, lambda: f.set_result(None)) yield f selector.unregister(self.sock.fileno()) print(f"{self._host} connect success") def request(self) -> Generator[Future, None, None]: # 发送请求， 并监听读事件， 以及注册对应的接收响应函数 yield from self.connected() self.sock.send(f"GET {self.url} HTTP/1.0\r\nHost: {self._host}\r\n\r\n".encode("ascii")) response = yield from self.read_response() print(f"request {self._host} success, length:{len(response)}") global running_cnt running_cnt -= 1if __name__ == "__main__": # 同时多个请求 Task(HttpRequest("so1n.me").request()) Task(HttpRequest("github.com").request()) Task(HttpRequest("google.com").request()) Task(HttpRequest("baidu.com").request()) # 监听是否有事件在运行 while running_cnt > 0: # 等待事件循环通知事件是否已经完成 for key, mask in selector.select(): key.data()

这段代码通过​​Future​​​和生成器方法尽量的解耦回调函数， 如果忽略了​​HttpRequest​​​中的​​connected​​​和​​read​​​方法则可以发现整段代码跟同步的代码基本上是一样的, 只是通过​​yield​​​和​​yield from​​​交出控制权和通过事件循环恢复控制权。同时通过上面的异常例子可以发现异常排查非常的方便， 这样一来就没有了回调的各种糟糕的事情， 开发者只需要按照同步的思路进行开发即可， 不过我们的事件循环是一个非常简单的事件循环例子， 同时对于socket相关都没有进行封装， 也缺失一些常用的API， 而这些都会被​​Python​​​官方封装到​​Asyncio​​​这个库中， 通过该库， 我们可以近乎完美的编写​​Async​​语法的代码。

NOTE: 由于生成器协程中无法通过​​yield from​​​语法使用生成器， 所以​​Python​​​在3.5之后使用了​​Await​​的原生协程。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。