8-3-1python语法基础-并发编程-协程创建以及协程的详细解释

前言

先看这个文章:
python进程,线程,协程,对比,思考: https://www.cnblogs.com/andy0816/p/15590085.html

协程

进程和线程是计算机提供的,协程是程序员创造的,不存在于计算机中。
协程也可称为微线程,一种用户态的上下文切换技术(通过一个线程实现代码块间的相互切换执行)在一个线程中,遇到io等待时间,线程可以利用这个等待时间去做其他事情。

协程的实现方式

  • 在Python中有多种方式可以实现协程

第一种方式:使用第三方模块greenlet(了解)

  • greenlet,是一个第三方模块,用于实现协程代码(Gevent协程就是基于greenlet实现)
  • greentlet是一个第三方模块,需要提前安装 pip3 install greenlet才能使用。
  • 在Python3.4之前官方未提供协程的类库,一般大家都是使用greenlet等其他来实现。
from greenlet import greenlet
def func1():
    print(1)        # 第1步:输出 1
    gr2.switch()    # 第3步:切换到 func2 函数
    print(2)        # 第6步:输出 2
    gr2.switch()    # 第7步:切换到 func2 函数,从上一次执行的位置继续向后执行
def func2():
    print(3)        # 第4步:输出 3
    gr1.switch()    # 第5步:切换到 func1 函数,从上一次执行的位置继续向后执行
    print(4)        # 第8步:输出 4
gr1 = greenlet(func1)
gr2 = greenlet(func2)
gr1.switch() # 第1步:去执行 func1 函数
注意:switch中也可以传递参数用于在切换执行时相互传递值。

第二种方法: yield和yield form关键字(了解)

  • yield,生成器,借助生成器的特点也可以实现协程代码。
  • 基于Python的生成器的yield和yield form关键字实现协程代码。
def func1():
    yield 1
    yield from func2()
    yield 2
def func2():
    yield 3
    yield 4
f1 = func1()
for item in f1:
    print(item)
注意:yield form关键字是在Python3.3中引入的。

第三种方法:纯使用asyncio实现(了解)

  • asyncio,在Python3.4中引入的模块用于编写协程代码。
  • 在Python3.4之前官方未提供协程的类库,一般大家都是使用greenlet等其他来实现。
  • 在Python3.4发布后官方正式支持协程,即:asyncio模块。
  • Python3.8之后 @asyncio.coroutine 装饰器就会被移除,推荐使用async & awit 关键字实现协程代码。
import asyncio
@asyncio.coroutine
def func1():
    print(1)
    yield from asyncio.sleep(2)  # 遇到IO耗时操作,自动化切换到tasks中的其他任务
    print(2)
@asyncio.coroutine
def func2():
    print(3)
    yield from asyncio.sleep(2) # 遇到IO耗时操作,自动化切换到tasks中的其他任务
    print(4)
tasks = [
    asyncio.ensure_future( func1() ),
    asyncio.ensure_future( func2() )
]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
注意:基于asyncio模块实现的协程比之前的要更厉害,因为他的内部还集成了遇到IO耗时操作自动切花的功能。

第四种方法:async和awiat关键字结合asyncio(必须掌握)

  • async & awiat,在Python3.5中引入的两个关键字,结合asyncio模块可以更方便的编写协程代码。
  • async & awit 关键字在Python3.5版本中正式引入,基于他编写的协程代码其实就是 上一示例 的加强版,
  • 让代码可以更加简便。
  • Python3.8之后 @asyncio.coroutine 装饰器就会被移除,推荐使用async & awit 关键字实现协程代码。

import asyncio
async def func1():
    print(1)
    await asyncio.sleep(2)
    print(2)
async def func2():
    print(3)
    await asyncio.sleep(2)
    print(4)
tasks = [
    asyncio.ensure_future(func1()),
    asyncio.ensure_future(func2())
]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

总结

  • 关于协程有多种实现方式,
  • 基于async & await关键字的协程可以实现异步编程,这也是目前python异步相关的主流技术。
  • 目前主流使用是Python官方推荐的asyncio模块和async&await关键字的方式,
  • 例如:在tonado、sanic、fastapi、django3 中均已支持。
  • 这种方式是必须要掌握的,其他的都了解就行了,

深刻理解上面的代码

深刻理解1---->async关键字和协程函数,协程对象

协程函数:

  • 函数前面加了一个async
  • 协程函数,定义形式为 async def 的函数。
  • 协程对象,调用 协程函数 所返回的对象。

注意,

  • async_test函数由于加了关键字,已经是协程函数,直接调用会返回协程对象,并不会执行函数内的代码。
# 定义一个协程函数
async def func():
    pass
# 调用协程函数,返回一个协程对象
result = func()
注意:调用协程函数时,函数内部代码不会执行,只是会返回一个协程对象。

深刻理解2---->await关键字

  • await是一个只能在协程函数中使用的关键字,用于遇到IO操作时挂起 当前协程(任务),
  • 当前协程(任务)挂起过程中 事件循环可以去执行其他的协程(任务),
  • 当前协程IO处理完成时,可以再次切换回来执行await之后的代码。

注意:

  • await后面是一个可等待对象,如协程对象、协程任务,用于告诉even loop在此协程中需要等待后面的函数运行完成后才能继续,运行完成后返回结果。

  • 协程函数调用时,前面不加await会显示以下内容
    RuntimeWarning: coroutine ‘xxx’ was never awaited

  • await要在协程函数里面,否则会显示以下内容
    ‘await’ outside function

深刻理解3---->asyncio模块和run

案例

import asyncio
import time


async def async_test(delay: int, content):
    await asyncio.sleep(delay)
    print(content)


async def main():
    await async_test(1, "lady")
    await async_test(2, "killer9")


if __name__ == '__main__':
    print(f"start at {time.strftime('%X')}")
    asyncio.run(main())
    print(f"end at {time.strftime('%X')}")

run
该函数用来运行最高层级的入口点,如下面的main函数,并返回main函数的执行结果。
run函数的源码:

def run(main, *, debug=False):
    if events._get_running_loop() is not None:
        raise RuntimeError(
            "asyncio.run() cannot be called from a running event loop")

    if not coroutines.iscoroutine(main):
        raise ValueError("a coroutine was expected, got {!r}".format(main))

    loop = events.new_event_loop()
    try:
        events.set_event_loop(loop)
        loop.set_debug(debug)
        return loop.run_until_complete(main)
    finally:
        try:
            _cancel_all_tasks(loop)
            loop.run_until_complete(loop.shutdown_asyncgens())
        finally:
            events.set_event_loop(None)
            loop.close()

可以看到run进行了一些类型判断等,之后创建了event loop,并且把main放到了event loop中。
我前面写的代码的整个流程如下:
asyncio.run(main()),把main返回的协程对象放到了event loop,转为了协程任务,event loop发现当前有一个可执行任务,开始执行,执行到await async_test(1,“lady”)时发现有await,需要等待协程对象,执行完之后再执行await async_test(2,“killer9”),所以耗时3秒。

深刻理解4---->Task对象

  • 协程任务:coroutine task,事件循环调度的最小单位,可由协程对象转化。
  • Tasks用于并发调度协程,通过asyncio.create_task(协程对象)的方式创建Task对象,参数是传入协程对象
  • 这样可以让协程加入事件循环中等待被调度执行。除了使用 asyncio.create_task() 函数以外,
  • 还可以用低层级的 loop.create_task() 或 ensure_future() 函数。不建议手动实例化 Task 对象。
  • 本质上是将协程对象封装成task对象,并将协程立即加入事件循环,同时追踪协程的状态。

注意:asyncio: Task, create_task, ensure_future 都可以创建任务,该用哪个?

  • 使用高层级的 asyncio.create_task() 函数来创建 Task 对象,也可用低层级的 loop.create_task() 或 ensure_future() 函数。不建议手动实例化 Task 对象。

  • 上面是三种方式实现的协程异步,有什么区别?
    从Python 3.7开始,为此目的添加了asyncio.create_task(coro)高级功能。
    您应该使用它来代替从coroutimes创建任务的其他方法。但是,如果您需要从任意等待创建任务,您应该使用asyncio.ensure_future(obj)。

  • asyncio.create_task() 函数在 Python 3.7 中被加入。在 Python 3.7 之前,可以改用低层级的 asyncio.ensure_future() 函数。

案例

import asyncio
import time
async def async_test(delay:int,content):
    await asyncio.sleep(delay)
    print(content)

async def main():
    task_lady = asyncio.create_task(async_test(1,"lady"))
    task_killer = asyncio.create_task(async_test(2,"killer9"))
    await task_killer

if __name__ == '__main__':
    print(f"start at {time.strftime('%X')}")
    asyncio.run(main())
    print(f"end at {time.strftime('%X')}")

结果如下:

start at 16:40:53
lady
killer9
end at 16:40:55

可以看到等待了2秒。

create_task代码如下

def create_task(coro):
    loop = events.get_running_loop()
    return loop.create_task(coro)

可以看到该函数获取了正在运行的even loop,生成了一个协程任务对象后返回。
我前面写的代码的整个流程如下:
asyncio.run(main())把main函数放到了event loop,转为了任务对象,此时even loop有一个任务可执行,执行过程中创建了async_test(1,“lady”)、async_test(2,“killer9”)两个任务,这两个任务并发执行。
由于博主知道task_killer 任务耗时最久,所以等待该任务完成后再结束即可。当你不知道时,可以await所有任务,此时任务依然是并行执行的,当然,如果你只await了耗时短的,那么其他任务没有完成就结束了,例如 await task_lady,此处读者可自行尝试。
结果如下:

start at 10:44:07
lady
3
end at 10:44:08

那么这里也有一个问题,如果创建很多任务,总不能一行一行的写await吧?接下来就看看如何并发等待

## 深刻理解5---->wait

并发执行协程函数等,返回done和pending状态的任务对象集合

import asyncio
import time
async def async_test(delay:int,content):
    await asyncio.sleep(delay)
    print(content)

if __name__ == '__main__':
    print(f"start at {time.strftime('%X')}")
    asyncio.run(asyncio.wait([async_test(1,"lady"),async_test(2,"killer")]))
    print(f"end at {time.strftime('%X')}")

结果如下:
start at 17:30:41
lady
killer
end at 17:30:43

可以看到等待了2秒。

wait原代码如下:

async def wait(fs, *, loop=None, timeout=None, return_when=ALL_COMPLETED):
    if futures.isfuture(fs) or coroutines.iscoroutine(fs):
        raise TypeError(f"expect a list of futures, not {type(fs).__name__}")
    if not fs:
        raise ValueError('Set of coroutines/Futures is empty.')
    if return_when not in (FIRST_COMPLETED, FIRST_EXCEPTION, ALL_COMPLETED):
        raise ValueError(f'Invalid return_when value: {return_when}')

    if loop is None:
        loop = events.get_event_loop()

    fs = {ensure_future(f, loop=loop) for f in set(fs)}

    return await _wait(fs, timeout, return_when, loop)

超时不会取消可等待对象、不会抛出异常asyncio.TimeoutError异常

深刻理解6---->wait_for

超时会取消可等待对象,会抛出异常,但是参数只接收一个coroutine

import asyncio
import time
async def async_test(delay:int,content):
    await asyncio.sleep(delay)
    print(content)

async def main():
    try:
        await asyncio.wait_for( async_test(2, "killer"),timeout=1)
    except asyncio.TimeoutError:
        print("任务超时...")

if __name__ == '__main__':
    print(f"start at {time.strftime('%X')}")
    asyncio.run(main())
    print(f"end at {time.strftime('%X')}")

结果如下:
start at 14:17:27
任务超时…
end at 14:17:28

可以看到超时后抛出异常了
wait_for代码如下:

async def wait_for(fut, timeout, *, loop=None):
    if loop is None:
        loop = events.get_event_loop()

    if timeout is None:
        return await fut

    if timeout <= 0:
        fut = ensure_future(fut, loop=loop)

        if fut.done():
            return fut.result()

        fut.cancel()
        raise futures.TimeoutError()

    waiter = loop.create_future()
    timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
    cb = functools.partial(_release_waiter, waiter)

    fut = ensure_future(fut, loop=loop)
    fut.add_done_callback(cb)

    try:
        try:
            await waiter
        except futures.CancelledError:
            fut.remove_done_callback(cb)
            fut.cancel()
            raise
        if fut.done():
            return fut.result()
        else:
            fut.remove_done_callback(cb)
            await _cancel_and_wait(fut, loop=loop)
            raise futures.TimeoutError()
    finally:
        timeout_handle.cancel()

可以看到对timeout进行了判断,raise了TimeoutError异常

深刻理解7---->gather

接收的是列表,结果将是一个由所有返回值聚合而成的列表。结果值的顺序与 aws 中可等待对象的顺序一致。如果 return_exceptions 为 False (默认),所引发的首个异常会立即传播给等待 gather() 的任务。aws 序列中的其他可等待对象 不会被取消 并将继续运行。

import asyncio
import time
async def async_test(delay:int,content):
    await asyncio.sleep(delay)
    return content

async def exception_test(delay:int,content):
    await asyncio.sleep(delay)
    raise TimeoutError("超时")
    return content


async def main():
    result_list = await asyncio.gather(exception_test(1,"lady"),async_test(2, "killer"),return_exceptions=True)
    return result_list

if __name__ == '__main__':
    print(f"start at {time.strftime('%X')}")
    res = asyncio.run(main())
    print(res)
    print(f"end at {time.strftime('%X')}")

结果如下:

start at 15:16:10
[TimeoutError(‘超时’), ‘killer’]
end at 15:16:12

可以看到return_exceptions=True时,一个任务抛出异常,其他的任务还会执行。

深刻理解8---->事件循环get_event_loop(扩展)

这个很少用了,future我也没提,都比较底层,这里简单说两个
通过asyncio.get_event_loop()获取事件循环,常用函数:
create_task:创建任务
run_until_complete:运行任务,返回结果

import asyncio
import time
async def async_test(delay:int,content):
    await asyncio.sleep(delay)
    print(content)
    return content

if __name__ == '__main__':
    print(f"start at {time.strftime('%X')}")
    event_loop = asyncio.get_event_loop()
    tasks = [event_loop.create_task(async_test(1,"lady")),event_loop.create_task(async_test(2,"killer"))]
    res = event_loop.run_until_complete(asyncio.wait(tasks))
    print(res)
    print(f"end at {time.strftime('%X')}")

结果如下:

start at 15:46:43
lady
killer
({<Task finished coro=<async_test() done, defined at E:/project_workspace/git_workspace/Script/coroutine_learn.py:3> result=‘lady’>, <Task finished coro=<async_test() done, defined at E:/project_workspace/git_workspace/Script/coroutine_learn.py:3> result=‘killer’>}, set())
end at 15:46:45

事件循环,可以把他当做是一个while循环,这个while循环在周期性的运行并执行一些任务,在特定条件下终止循环。
import asyncio
loop = asyncio.get_event_loop()

事件循环和协程对象

  • 程序中,如果想要执行协程函数的内部代码,需要 事件循环 和 协程对象 配合才能实现,如:
import asyncio
async def func():
    print("协程内部代码")
# 调用协程函数,返回一个协程对象。
result = func()
# 方式一
# loop = asyncio.get_event_loop() # 创建一个事件循环
# loop.run_until_complete(result) # 将协程当做任务提交到事件循环的任务列表中,协程执行完成之后终止。
# 方式二
# 本质上方式一是一样的,内部先 创建事件循环 然后执行 run_until_complete,一个简便的写法。
# asyncio.run 函数在 Python 3.7 中加入 asyncio 模块,
asyncio.run(result)
这个过程可以简单理解为:将协程当做任务添加到 事件循环 的任务列表,然后事件循环检测列表中的协程是否 已准备就绪(默认可理解为就绪状态),如果准备就绪则执行其内部代码。

异步上下文管理器

  • 这个异步的上下文管理器还是比较有用的,平时在开发过程中 打开、处理、关闭 操作时,就可以用这种方式来处理。
import asyncio
class AsyncContextManager:
    def __init__(self):
        self.conn = conn
    async def do_something(self):
        # 异步操作数据库
        return 666
    async def __aenter__(self):
        # 异步链接数据库
        self.conn = await asyncio.sleep(1)
        return self
    async def __aexit__(self, exc_type, exc, tb):
        # 异步关闭数据库链接
        await asyncio.sleep(1)
async def func():
    async with AsyncContextManager() as f:
        result = await f.do_something()
        print(result)
asyncio.run(func())

uvloop

Python标准库中提供了asyncio模块,用于支持基于协程的异步编程。
uvloop是 asyncio 中的事件循环的替代方案,替换后可以使得asyncio性能提高。
事实上,uvloop要比nodejs、gevent等其他python异步框架至少要快2倍,性能可以比肩Go语言。
安装uvloop
pip3 install uvloop
在项目中想要使用uvloop替换asyncio的事件循环也非常简单,只要在代码中这么做就行。

import asyncio
import uvloop
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
# 编写asyncio的代码,与之前写的代码一致。
# 内部的事件循环自动化会变为uvloop
asyncio.run(...)
注意:知名的asgi uvicorn内部就是使用的uvloop的事件循环。

如何使用异步?

  • 我要使用我自己的一个例子,
  • 上代码:
import time
import asyncio
import aiohttp

import redis
import queue
import logging

logging.basicConfig(level=logging.INFO,
                    format=
                    # 日志的时间
                    '%(asctime)s'
                    # 日志级别名称 : 当前行号
                    ' %(levelname)s [%(filename)s : %(lineno)d ]'
                    # 日志信息
                    ' : %(message)s'
                    # 指定时间格式
                    , datefmt='[%Y/%m/%d %H:%M:%S]')
logging = logging.getLogger(__name__)

# 第一步,把数据取出来,在redis
conn = redis.Redis(host="127.0.0.1", port="6379")
# proxy_list = conn.hgetall("use_proxy")
# proxy_list = conn.hvals("use_proxy")
proxy_list = conn.hkeys("use_proxy")
# logging.info(proxy_list)

# 第二步,把数据存入队列
proxy_queue = queue.Queue()
for proxy in proxy_list:
    proxy_queue.put(str(proxy, encoding="utf-8"))
queue_size = proxy_queue.qsize()


# logging.info(queue_size)
# logging.info(proxy_queue.get())


async def fetch(session):
    while True:
        try:
            proxy = proxy_queue.get(block=False)
            # print(proxy_queue.qsize())
        except queue.Empty:
            break
        headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:34.0) Gecko/20100101 Firefox/34.0',
                   'Accept': '*/*',
                   'Connection': 'keep-alive',
                   'Accept-Language': 'zh-CN,zh;q=0.8'}
        # 代理验证目标网站
        url_http = "http://httpbin.org/ip"
        url_https = "https://www.qq.com"
        http_code = False
        https_code = False
        proxy = "http://{}".format(proxy)

        # 第一个任务到这个地方遇到了阻塞,就会挂起,然后执行第二个任务,直到所有协程都执行起来,这个时候事件循环里面是有1个main协程,多个协程
        try:
            async with session.head(url_http, headers=headers, proxy=proxy, verify_ssl=False, timeout=10) as response:
                res_http = response.status
                if res_http == 200:
                    http_code = True
        except Exception as e:
            http_code = False

        try:
            async with session.get(url_https, headers=headers, proxy=proxy, verify_ssl=False, timeout=10) as response:
                res_https = response.status
                if res_https == 200:
                    https_code = True
        except Exception as e:
            https_code = False

        if http_code and https_code:
            logging.info("http_status:{} https_status:{} 代理:{} ".format(str(http_code).ljust(6),
                                                                        str(https_code).ljust(6), proxy.ljust(25)))


async def main():
    async with aiohttp.ClientSession() as session:
        task_list = []
        for i in range(20):
            # t = asyncio.create_task(fetch(session))
            # task_list.append(t)
            # 上面两行,不要这么写,这么写就是同步的效果了,就不是异步的效果了
            # # 这一步是创建task任务,并且都加入到事件循环中,里面是传入一个协程对象,
            task_list.append(asyncio.create_task(fetch(session)))

        for i in task_list:
            # 这个await 是等待返回,一直要等待返回值之后,才会往下走,这个时候main协程是挂起的状态,
            # 如果没有这个for循环,发现main函数结束了之后,hi协程并没有结束,整个的协程就结束了,
            # 所以main是主的,其他是子的,主的结束了,子的不管有没有结束都会结束,
            # 有点像是多线程里面的join,但是又不太一样,
            await i


if __name__ == '__main__':
    # 这个run,是创建事件循环,并且把main() 协程加入事件循环中,这个是一个主线程
    asyncio.run(main())

协程总结:

  • 协程(Coroutine),也可以被称为微线程,是一种用户态内的上下文切换技术。
  • 其实就是通过一个线程实现代码块相互切换执行。
  • 但是,协程来回切换执行的意义何在呢?协程牛逼的地方到底在哪里呢??
  • 计算型的操作,利用协程来回切换执行,没有任何意义,来回切换并保存状态 反倒会降低性能。
  • IO型的操作,利用协程在IO等待时间就去切换执行其他任务,当IO操作结束后再自动回调,
  • 那么就会大大节省资源并提供性能,从而实现异步编程(不等待任务结束就可以去执行其他代码)。

总结

  • 为了提升性能越来越多的框架都在向异步编程靠拢,目的就是用更少资源可以做处理更多的事
  • 比如:FastAPI、Tornado、Sanic、Django 3、aiohttp等。
  • 现在身边使用python的人,聊异步的也越来越多了,异步如何如何牛逼,性能如何吊炸天
  • 水涨船高,别人会,你不会你就落后了,落后就要挨打
posted @ 2021-07-22 01:45  技术改变命运Andy  阅读(119)  评论(0编辑  收藏  举报