答疑·限时优惠

如果,你想让我看见你的疑问并且百分之百的回答。可以加入我的知识星球。
AI悦创·进化岛
AI悦创·进化岛

你好,我是悦创。

在 Python 3.4 时候引进了协程的概念,它使用一种单线程单进程的的方式实现并发。谈到并发,大多数朋友想到更多的应该是多进程和多线程,它们都是比较消耗系统资源的,今天我们不谈线程和进程,而是来说下当前比较火的协程。

因为在爬虫操作中,协程比多线程更有优势。协程是单线程的,单线程就能实现高并发。

什么是协程?

协程,英文名是 Coroutine, 又称为微线程,是一种用户态的轻量级线程。协程不像线程和进程那样,需要进行系统内核上的上下文切换,协程的上下文切换是由程序员决定的。在 Python 中协程就是一个可以暂停执行的函数,听起来和生成器的概念一样。

协程的发展

从 Python3.4 开始协程被加入到标准库,当时的协程是通过 @asyncio.coroutine 和 yeild from 实现的,看起来和生成器的实现方式没什么区别。后来为了更好的区分开协程和生成器,到 Python3.5 的时候引入 async/await 语法糖临时定格了下来,直到 Python3.6 的时候才被更多的人认可,Python3.6 作为 Python3 目前最稳定的版本拥有大量的使用者,后来到了 Python3.7 官方把 async 和 await 作为保留字,同时协程的调用也变得简单了许多,但是,正是保留字的原因导致之前很多 async 为函数名的库报错,典型的有 scrapy,所以这里推荐大家使用 Python3.6。

协程相对于多线程的优点

多线程编程是比较困难的, 因为调度程序任何时候都能中断线程, 必须记住保留锁, 去保护程序中重要部分, 防止多线程在执行的过程中断。

而协程默认会做好全方位保护, 以防止中断。我们必须显示产出才能让程序的余下部分运行。对协程来说, 无需保留锁, 而在多个线程之间同步操作, 协程自身就会同步, 因为在任意时刻, 只有一个协程运行。总结下大概下面几点:

  • 无需系统内核的上下文切换,减小开销;
  • 无需原子操作锁定及同步的开销,不用担心资源共享的问题;
  • 单线程即可实现高并发,单核 CPU 即便支持上万的协程都不是问题,所以很适合用于高并发处理,尤其是在应用在网络爬虫中。

协程的定义

使用协程也就意味着你需要一直写异步方法。在 Python 中我们使用 asyncio 模块来实现一个协程。如果我们把 Python 中普通函数称之为同步函数(方法),那么用协程定义的函数我们称之为异步函数(方法)。

注意,以下所有的代码实例运行环境均要求版本大于等于 Python3.6。

同步函数和异步函数的定义

同步函数定义

def regular_double(x):
    return 2 * x

异步函数定义

async def async_double(x):
    return 2 * x

同步函数和异步函数的调用

对于同步函数我们知道是这样调用的:

 regular_double(2)

异步函数如何调用呢?带着这个问题我们看下面的一个简单例子。

import asyncio

async def foo():
    print("这是一个协程")


if __name__ == '__main__':
    loop = asyncio.get_event_loop() # 定义一个事件循环
    try:
        print("开始运行协程")
        coro = foo()
        print("进入事件循环")
        loop.run_until_complete(coro) # 运行协程
    finally:
        print("关闭事件循环")
        loop.close() # 运行完关闭协程

这就是最简单的一个协程的例子,让我们了解一下上面的代码。

首先,需要导入需要的包 -asyncio。然后,创建一个事件循环,因为协程是基于事件循环的。 之后,通过 run_until_complete 方法传入一个异步函数,来运行这个协程。 最后在结束的时候调用 close 方法关闭协程。 综上就是调用一个协程的写法。除此之外协程还有其他的不同之处。

协程之间的链式调用

我们可以通过使用 await 关键字,在一个协程中调用一个协程。 一个协程可以启动另一个协程,从而可以使任务根据工作内容,封装到不同的协程中。我们可以在协程中使用 await 关键字,链式地调度协程,来形成一个协程任务流。像下面的例子一样:

import asyncio


async def main():
    print("主协程")
    print("等待result1协程运行")
    res1 = await result1()
    print("等待result2协程运行")
    res2 = await result2(res1)
    return (res1,res2)


async def result1():
    print("这是result1协程")
    return "result1"


async def result2(arg):
    print("这是result2协程")
    return f"result2接收了一个参数,{arg}"


if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    try:
        result = loop.run_until_complete(main())
        print(f"获取返回值:{result}")
    finally:
        print("关闭事件循环")
        loop.close()

输出:

主协程
等待result1协程运行
这是result1协程
等待result2协程运行
这是result2协程
获取返回值:('result1', 'result2接收了一个参数,result1')
关闭事件循环

在上面,我们知道调用协程需要通过创建一个事件循环然后再去运行。 这里我们需要了解的是如果在协程里想调用一个协程我们需要使用 await 关键字,就拿上面的例子来说在 main 函数里调用协程 result1 和 result2。 那么问题来了:await 干了什么呢?

await 的作用

await 的作用就是等待当前的协程运行结束之后再继续进行下面代码。 因为我们执行 result1 的时间很短,所以在表面上看 result1 和 result2 是一起执行的。这就是 await 的作用。等待一个协程的执行完毕,如果有返回结果,那么就会接收到协程的返回结果,通过使用 return 可以返回协程的一个结果,这个和同步函数的 return 使用方法一样。

并发的执行任务

一系列的协程可以通过 await 链式调用,但是有的时候我们需要在一个协程里等待多个协程,比如我们在一个协程里等待 1000 个异步网络请求,对于访问次序没有要求的时候,就可以使用关键字 wait 来解决了。wait 可以暂停一个协程,直到后台操作完成。

Task 的使用

import asyncio


async def num(n):
    print(f"当前的数字是:{n}")
    await asyncio.sleep(n)
    print(f"等待时间:{n}")


async def main():
    tasks = [num(i) for i in range(10)] #协程列表
    #await asyncio.gather(*tasks) #有序并发
    await asyncio.wait(tasks) #并发运行协程列表的协程


if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    try:
        loop.run_until_complete(main())
    finally:
        loop.close()

输出:

当前的数字是:0
当前的数字是:4
当前的数字是:8
当前的数字是:1
当前的数字是:5
当前的数字是:7
当前的数字是:2
当前的数字是:6
当前的数字是:9
当前的数字是:3
等待时间:0
等待时间:1
等待时间:2
等待时间:3
等待时间:4
等待时间:5
等待时间:6
等待时间:7
等待时间:8
等待时间:9

如果运行的话会发现首先会打印 10 次数字,但是并不是顺序执行的,这也说明 asyncio.wait 并发执行的时候是乱序的。如果想保证顺序只要使用 gather 把 task 写成解包的形式就行了,也就是上面的注释部分的代码。

如何在协程中使用普通的函数呢?

我们知道在普通函数中调用普通函数之间,函数名加括号即可,像下面这样:

def foo():
   print("这是一个普通函数")
   return "test"

def main():
   print("调用foo函数") 
   res=foo()
   print(f"{接收到来自foo函数的值}:res")
if __name__=="__main__"
   main()

那么在协程中如何使用一个普通函数呢? 在协程中可以通过一些方法去调用普通的函数。可以使用的关键字有 call_soon 等。

call_soon

可以通过字面意思理解调用立即返回。 下面来看一下具体的使用例子:

import asyncio
import functools


def callback(args, *, kwargs="defalut"):
    print(f"普通函数做为回调函数,获取参数:{args},{kwargs}")


async def main(loop):
    print("注册callback")
    loop.call_soon(callback, 1)
    wrapped = functools.partial(callback, kwargs="not defalut")
    loop.call_soon(wrapped, 2)
    await asyncio.sleep(0.2)


if __name__ == '__main__':
    loop = asyncio.get_event_loop()
try:
    loop.run_until_complete(main(loop))
finally:
    loop.close()

输出结果:

注册callback
普通函数做为回调函数,获取参数:1,defalut
普通函数做为回调函数,获取参数:2,not defalut

通过输出结果我们可以发现我们在协程中成功调用了一个普通函数,顺序地打印了 1 和 2。

看过这些例子之后,也许你就有疑问了,协程没有缺点的么?

协程的缺点

同样的总结下大概以下 2 点。

无法使用 CPU 的多核

协程的本质是个单线程,它不能同时用上单个 CPU 的多个核,协程需要和进程配合才能运行在多 CPU 上。当然我们日常所编写的绝大部分应用都没有这个必要,就比如网络爬虫来说,限制爬虫的速度还有其他的因素,比如网站并发量、网速等问题都会是爬虫速度限制的因素。除非做一些密集型应用,这个时候才可能会用到多进程和协程。

处处都要使用非阻塞代码

写协程就意味着你要一值写一些非阻塞的代码,使用各种异步版本的库,比如后面的异步爬虫教程中用的 aiohttp 就是一个异步版本的request库等。 不过这些缺点并不能影响到使用协程的优势。

小结

对于协程的入门来说,这些知识已经够用了。当然协程涉及到的知识不止这些,这里只是为了大家提前对协程有一定的了解,后面将继续讲解协程的其他知识,一切的协程知识基础都是为后面的异步爬虫教程做准备,只有熟悉了使用协程才能在后面教程中快速上手操作。 接下来将进一步提到本文没有提及的事件循环、Task、Future、Awaitable 等一系列知识点,以及协程的高层 API 知识。敬请期待!

AI悦创·创造不同!
AI悦创 » 10 分钟入门 Python 协程

Leave a Reply