python中的协程(1)

1、协程概念

协程：称为微线程，是一种用户态的轻量级线程。
发展历程：
（1）最初的生成器变形yied/send;
（2）引入@asyncio.coroutine 和 yield from
（3）在python3.5版本中引入了async和await关键字
【协程理解】
  (1)普通理解：线程是级别的，他们是又操作系统调度；协程是程序级别的，由程序员根据需要自己调度。我们把一个线程中的一个个函数称为子程序。那么子程序在执行过程中可以中断执行别的子程序。别的子程序也可以中断回来继续执行之前的子程序，这就是协程。

 子程序：在所有的语言中都是层级调用，是通过栈实现的，一个线程就是执行一个子程序，子程序的调用总是一个入口，一次返回，调用的顺序是明确的。
(2)专业理解：协程拥有自己的寄存器上下文和栈，协程在调度切换时，将寄存器上下文和栈保存到其他的地方，在切回时，恢复先前保存的寄存器上下文和栈。因此，协程能保留上一次调用时的状态。
  因此每次过程重入时，就相当于进入上一次调用的状态。
【协程优点】
 （1）无需线程上下文切换的开销，协程避免了无意义的调度，由此提高了性能，但是，程序必须自己承担调度的责任，同时协程也失去了标准线程使用多cpu的能力。
（2）无需原子操作锁定及同步的开销。
（3）方便切换控制流，简化编程模型。
（4）高并发+高扩展性+低成本，一个cpu支持上万个协程不是问题。
【协程缺点】
（1）无法利用多核资源，协程的本质是单个线程，它不能同时将单个cpu的多个核使用，协程需要和进程配合使用才能运行在多核cpu上。但是一般不需要，除非是cpu密集型的应用。
（2）进行阻塞操作(耗时IO)会阻塞程序

【迭代传递数据】

####数据传递
def fun():
    data = "#"
    # yield 不但可以返回一个值，并且它还可以接收调用者发送的参数
    r =yield  data
    print("-------------1-------------------",r,data)
    r =yield  data
    print("-------------2-------------------",r,data)
    r =yield  data
    print("-------------3-------------------",r,data)
    r = yield data
g = fun()
# print(g,type(g)) # <generator object fun at 0x000001C73A4534F8> <class 'generator'>
# next无法传参，只能拿到返回值,传递参数需要使用send
print(g.send(None)) # send就是启动
print(g.send("a"))
print(g.send("b"))
print(g.send("c"))
# print(next(g))

【异步】

   异步是和同步相对的，指在处理调用这个事务之后，不会等待这个事务的处理结果，直接去处理第二个事务了，通过状态、通知、回调来通知调用者处理结果。

import time
import asyncio
# async就是定义异步函数(也就是定义一个协程)
async  def func():
    # 模拟一个耗时IO操作
    asyncio.sleep(1)
    print("time:%s" % time.time())
loop = asyncio.get_event_loop()
for i in range(5):
    loop.run_until_complete(func())

2、asyncio模块

 python3.5内置了asyncio对异步IO支持。
编程模式：是有一个消息循环，我们从asyncio模块中直接获取一个EventLoop的引用，然后把需要执行的协程仍到EventLoop中执行，就实现了异步。
说明：到目前为止实现协程的不仅只有asyncio，还有gevent和tornado都实现了类似的功能。
【关键字】
（1）event_loop 事件循环：程序开启一个无限循环也就是死循环，把一些函数注册到事件循环中；当满足条件发送时，调用相应的协程函数
（2）coroutine 协程：协程对象，指一个使用async关键字定义的函数，它的调用不会立即执行函数，而是会返回一个协程对象。协程对象需要注册到事件循环中，是由事件循环调用。
（3） task 任务：一个协程对象就是一个原生可以挂起的函数，任务则是对协程进一步的封装，其中包含了任务的各种状态。
（4） future:英文单词含义是将来，代表将来执行或没有执行的任务的结果，它和task和是哪个没有本质区别；
（5）async/await:python3.5用定义协程的关键字。async定义协程，await用于挂起阻塞异步调用接口。

2.1、定义一个协程

import time
import asyncio
# 通过async关键字定义了一个协程，，协程不能直接运行，需要将协程加入到事件循环中
async def run(x):
    print("waiting:%d" %x)
start = time.time()
coroutine = run(2) # 得到一个协程对象，这个时候run()函数没有执行
print(coroutine) # <coroutine object run at 0x000002B07ADC74C8> 发现没有调用

loop = asyncio.get_event_loop() # 创建一个事件循环(注意：其实真是情况是asyncio模块中获取一个引用)

# 将协程对象加入到事件循环中
loop.run_until_complete(coroutine)

end = time.time()
print("Time:",end-start)

运行结果如下：

<coroutine object run at 0x000002351F018448>
waiting:2
Time: 0.006769657135009766

2.2、定义一个task任务

import asyncio
import time
async def run(x):# 定义协程对象
    print("waiting:%d" %x)
start = time.time()
coroutine = run(2) # 得到一个协程对象，这个时候run()函数没有执行
print(coroutine) 
loop = asyncio.get_event_loop() # 创建一个事件循环(注意：其实真是情况是asyncio模块中获取一个引用)
# 将协程对象加入到事件循环中,协程对象不能直接运行，在注册事件循环的时候，其实是run_until_complete()方法将协程对象包装成了一个任务对象
# task任务对象是Future类的子类对象，保存了协程运行后的状态，用于未来获取协程的结果。
# loop.run_until_complete(coroutine)
# 创建任务
task =  asyncio.ensure_future(coroutine)
# 第二种创建任务方式 task = loop.create_task(coroutine)
print(task)
#将任务加入事件循环中
loop.run_until_complete(task)
end = time.time()
print("Time:",end-start)

运行结果如下：

<coroutine object run at 0x0000021B568B9448>
<Task pending coro=<run() running at D:/py_workspace/spider_project/01异步/2创建一个任务task.py:6>>
waiting:2
Time: 0.0035004615783691406

2.3、协程绑定回调

import asyncio
import time
async def run(x):
    print("waiting:%d" %x)
    return  "done after %d" %x
def callback(future): # 定义一个回调函数，参数为future，任务对象
    print("callback",future.result())
start = time.time()
coroutine = run(2) # 得到一个协程对象，这个时候run()函数没有执行
loop = asyncio.get_event_loop() # 创建一个事件循环(注意：其实真是情况是asyncio模块中获取一个引用)
task =  asyncio.ensure_future(coroutine) # 创建任务
task.add_done_callback(callback) # 给任务添加回调，在任务结束后调用回调函数
loop.run_until_complete(task)#将任务加入事件循环中
end = time.time()
print("Time:",end-start)

运行结果：

waiting:2
callback done after 2
Time: 0.0018661022186279297

2.4、阻塞和await

import asyncio
import time
async def run(x):
    # async定义协程对象，使用await可以针对耗时的操作进行挂起，就像生成器yield一样，函数交出控制权。
    # 协程遇到await事件循环将会挂起该协程，执其他协程，直到其他协程也挂起或者执行完毕，再进行下一个协程的执行
    print("waiting:%d" % x)
    # 调用一个耗时IO操作
    await asyncio.sleep(x) # asyncio.sleep另一个协程对象
    return "done after %d over" % x

def callback(future):
    print("callback:",future.result())

start = time.time()
coroutine = run(10) # 得到一个协程对象，这个时候run()函数没有执行
loop = asyncio.get_event_loop() # 创建一个事件循环(注意：其实真是情况是asyncio模块中获取一个引用)
task =  asyncio.ensure_future(coroutine) # 创建任务
task.add_done_callback(callback)
loop.run_until_complete(task)#将任务加入事件循环中
end = time.time()
print("Time:",end-start)

运行结果：

waiting:10
callback: done after 10 over
Time: 10.019726753234863