1、协程简介

协程，又称微线程，纤程。协程的作用是在执行函数A时可以随时中断去执行函数B，然后中断函数B继续执行函数A（可以*切换）。但这一过程并不是函数调用，这一整个过程看似像多线程，然而协程只有一个线程执行。

2、实现协程的方法

• greenlet早期模块
• yield 关键字
• asyncio 装饰器(python3.4)
• async、await关键字(python3.5)[推荐]

2.1、 greenlet实现协程

安装greenlet
pip install greenlet

from greenlet import greenlet


def func1():
    print(1)  # 第二步 打印1
    gr2.switch()  # 第三步，切换到func2函数
    print(2)  # 第六步, 打印2
    gr2.switch()  # 第七步 切换到fun2函数, 从上一次执行的位置继续向后执行


def func2():
    print(3)  # 第四步 打印3
    gr1.switch()  # 第五步 切换到fun1函数，从上一次执行的位置继续向后执行
    print(4)  # 第八部 打印4


gr1 = greenlet(func1)
gr2 = greenlet(func2)
gr1.switch()  # 第一步 去执行func1函数

2.2、yield关键字

def fun1():
    yield 1
    yield from fun2()
    yield 2

def fun2():
    yield 3
    yield 4

f1 = fun1()
for item in f1:
    print(item)

2.3、asyncio

python3.4

import asyncio

@asyncio.coroutine
def fun1():
    print(1)
    yield from asyncio.sleep(2)
    print(2)


@asyncio.coroutine
def fun2():
    print(3)
    yield from asyncio.sleep(2) #遇到IO耗时操作,自动切换到tasks中的其他任务。
    print(4)

tasks = [
    asyncio.ensure_future(fun1()),
    asyncio.ensure_future(fun2())
]

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

2.4、async & await关键字

python3.5

import asyncio


async def fun1():
    print(1)
    await asyncio.sleep(2)
    print(2)



async def fun2():
    print(3)
    await asyncio.sleep(2)
    print(4)

tasks = [
    asyncio.ensure_future(fun1()),
    asyncio.ensure_future(fun2())
]

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

3.1、事件循环

理解成一个死循环

# 伪代码
任务列表 = [任务1, 任务2, 任务3]
while True:
	# 可执行的任务列表,已完成的任务列表 = 去任务列表检查所有任务, 将'可执行'和'已完成'的任务返回
	for 就绪任务 in 可执行的任务列表:
		执行已就绪的任务
	for 已完成的任务 in 已完成的任务列表:
		在任务列表中移除 已完成的任务
	如果任务列表中的任务完成, 则终止循环

import asyncio
# 去生成一个事件循环
loop = asyncio.get_event_loop()
# 将任务放到任务列表
loop.run_until_complete(任务)

3.2、快速上手

协程函数:定义函数时候async def 函数名。
协程对象: 执行协程函数() 得到的协程对象。

注意: 执行协程函数创建协程对象, 代码内部函数不会执行

如果想要运行协程函数的内部代码，必须将协程对象交给事件循环来处理.

import asyncio
async def fun():
	print('学习协程')
result = func()

# 去生成一个事件循环
loop = asyncio.get_event_loop()
# 将任务放到任务列表
loop.run_until_complete(result)

asyncio.run(result) # python3.7

3.3、await 关键字

await + 可等待的对象(协程对象, Future,Task对象 ->IO等待)

import asyncio


async def other():
    print('start')
    await asyncio.sleep(2)
    print("end")
    return '返回值'


async def fun():
    print('执行协程函数内部代码')
    # 遇到IO操作挂起当前线程(任务), 等IO操作完成之后再继续往下执行。事件循环可以去执行其他协程(任务)
    result = await other()
    print('IO请求结束,结果为', result)


asyncio.run(fun())

await就是等待对象的值得到结果之后再继续想下走

3.4、Task对象

在事件循环中添加多个任务。

Tasks用于并发调度线程, 通过asyncio.create_task(协程对象)的方式创建Task对象,这样可以让协程加入事件循环中等待被调度执行。除了使用 asyncio.create_task()函数外,还可以用底层级的loop.create_task()或ensure_future()函数。不建议手动实例化Task对象。

import asyncio
async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return "返回值"
async def main():
    print("main开始")
    # 创建协程，将协程封装到Task对象中并添加到事件循环的任务列表中，等待事件循环去执行（默认是就绪状态）。
    # 在调用
    task_list = [
        asyncio.create_task(func(), name="n1"),
        asyncio.create_task(func(), name="n2")
    ]
    print("main结束")
    # 当执行某协程遇到IO操作时，会自动化切换执行其他任务。
    # 此处的await是等待所有协程执行完毕，并将所有协程的返回值保存到done
    # 如果设置了timeout值，则意味着此处最多等待的秒，完成的协程返回值写入到done中，未完成则写到pending中。
    done, pending = await asyncio.wait(task_list, timeout=None)
    print(done, pending)
asyncio.run(main())

3.5、asyncio.Future对象

Task继承Future,Task对象内部await结果的处理基于Future对象来的。

async def main():
    # 获取当前事件循环
    loop = asyncio.get_running_loop()
    # # 创建一个任务（Future对象），这个任务什么都不干。
    fut = loop.create_future()
    # 等待任务最终结果（Future对象），没有结果则会一直等下去。
    await fut
asyncio.run(main())

import asyncio
async def set_after(fut):
    await asyncio.sleep(2)
    fut.set_result("666")
async def main():
    # 获取当前事件循环
    loop = asyncio.get_running_loop()
    # 创建一个任务（Future对象），没绑定任何行为，则这个任务永远不知道什么时候结束。
    fut = loop.create_future()
    # 创建一个任务（Task对象），绑定了set_after函数，函数内部在2s之后，会给fut赋值。
    # 即手动设置future任务的最终结果，那么fut就可以结束了。
    await loop.create_task(set_after(fut))
    # 等待 Future对象获取 最终结果，否则一直等下去
    data = await fut
    print(data)
asyncio.run(main())

3.6、concurrent.future.Future对象

这个对象是基于线程池和进程池实现异步操作时使用的对象。

import time
from concurrent.futures import Future
from concurrent.futures.thread import ThreadPoolExecutor
from concurrent.futures.process import ProcessPoolExecutor
def func(value):
    time.sleep(1)
    print(value)
    return 123
pool = ThreadPoolExecutor(max_workers=5)
# 或 pool = ProcessPoolExecutor(max_workers=5)
for i in range(10):
    fut = pool.submit(func, i)
    print(fut)

4.1、uvloop

uvloop是 asyncio 中的事件循环的替代方案，替换后可以使得asyncio性能提高。事实上，uvloop要比nodejs、gevent等其他python异步框架至少要快2倍，性能可以比肩Go语言。

#安装
pip3 install uvloop

在项目中想要使用uvloop替换asyncio的事件循环也非常简单，只要在代码中这么做就行。

import asyncio
import uvloop
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
# 编写asyncio的代码，与之前写的代码一致。
# 内部的事件循环自动化会变为uvloop
asyncio.run(...)