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的人，聊异步的也越来越多了，异步如何如何牛逼，性能如何吊炸天
• 水涨船高，别人会，你不会你就落后了，落后就要挨打