Python43_协程再讲

greenlet的应用

import greenlet
import random
def producer():
    while True:
        item = random.randint(0,99)
        print("生成数字：%d"%item)
        c.switch(item)
def consumer():
    while True:
        item = p.switch()   #从另一个协程获得它所传递的数据
        print("消费数字：%d"%item)

if __name__ == "__main__":
    c = greenlet.greenlet(consumer)
    p = greenlet.greenlet(producer)
    c.switch()  #切换到c里面运行
    #swtich()有参数就是将参数传递给另一个协程，否则就是激活协程

gevent的应用

以后协程的实现主要用gevent

gevent是第三方库，通过greenlet实现协程，其基本思想是：

当一个greenlet遇到IO操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO。

由于切换是在IO操作时自动完成，所以gevent需要修改Python自带的一些标准库，这一过程在启动时通过monkey patch完成。

greenlet对yield实现了封装，gevent对greenlet再次实现了封装

代码示例（和线程非常类似）：

import gevent
from gevent.queue import Queue
import random

def Consume(queue):
        while True:
            gevent.sleep(random.random())	#gevent有一个特点，遇到了延时（如此处的gevent.sleep()）就切换，没有遇到延时就不切换。那么以后在网络编程中，如recv等造成的延时时，就需要用gevent里面的recv
            item=queue.get()
            print("消费者，消费:%s"%item)


def Consume2(queue):
    while True:
        gevent.sleep(random.random())	
        item = queue.get()
        print("消费者2，消费:%s" % item)

def Produce(queue):
        while True:
            gevent.sleep(random.random())
            item = random.randint(0,99)
            queue.put(item)
            print("生产者，生产：%s"%item)


def Produce2(queue):
    while True:
        gevent.sleep(random.random())
        item = random.randint(100, 199)
        queue.put(item)
        print("生产者2，生产：%s" % item)

queue = Queue(5)

p=gevent.spawn(Produce,queue)	# spawn：产卵。此时不会执行
p2=gevent.spawn(Produce2,queue)
c=gevent.spawn(Consume,queue)
c2=gevent.spawn(Consume2,queue)	
gevent.joinall([p,p2,c,c2])	#也可以通过p.join()、c.join()的方法
#

猴子补丁

作用：因为gevent要在遇到了gevent里面的延时操作时才切换，为了在不更改已有程序的基础上实现其切换，如：time.sleep()，就需要用到猴子补丁

import gevent
from gevent import monkey
import time

monkey.patch_all()	# 会自己更改代码里面的延时操作

def f1(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        time.sleep(0.5)

def f2(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        time.sleep(0.5)

def f3(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        time.sleep(0.5)

g1 = gevent.spawn(f1, 5)
g2 = gevent.spawn(f2, 5)
g3 = gevent.spawn(f3, 5)

gevent.joinall([g1, g2, g3])

协程函数（异步函数）

法一：async

#法一：
async def test1():
    print(1)
    await test2()   #test1在此等待，转去执行test2，test2执行完毕后再到此处继续执行
    print(2)
    return "haha"

async def test2():
    print(3)
    print(4)

try:
    a = test1()
    a.send(None)	#send None激活协程
except StopIteration as d:
    print(d.value)	#获得a的返回值“haha“
'''运行结果如下：
1
3
4
2
haha
'''

法二：asyncio

async def test1():
    print(1)
    await test2()   #test1在此等待，转去执行test2，test2执行完毕后再到此处继续执行
    print(2)
    return "stop"

async def test2():
    print(3)
    print(4)

import asyncio
loop = asyncio.get_event_loop()
#创建一个task类型的对象（即任务）
task = asyncio.ensure_future(test1())   #将协程变成了task类型
loop.run_until_complete(task)
print(task.result())    #获得task类型的执行结果
'''运行结果如下：
1
3
4
2
stop
'''

一次执行多个任务

async def test1():
    print(1)
    await test2()   #test1在此等待，转去执行test2，test2执行完毕后再到此处继续执行
    #await必须和async结合使用，一旦有了await，就必须有async
    print(2)
    return "stop"

async def test2():
    print(3)
    print(4)


import asyncio
loop = asyncio.get_event_loop()
tasks = [
    asyncio.ensure_future(test1()),
    asyncio.ensure_future(test1()),
    asyncio.ensure_future(test1()),
]

loop.run_until_complete(asyncio.wait(tasks))

for task in tasks:
    print(task.result())

'''运行结果如下：
1
3
4
2
1
3
4
2
1
3
4
2
stop
stop
stop
'''

添加回调函数

async def test1():
    print(1)
    await test2()   #test1在此等待，转去执行test2，test2执行完毕后再到此处继续执行
    #await必须和async结合使用，一旦有了await，就必须有awati
    print(2)
    return "stop"

async def test2():
    print(3)
    print(4)


import asyncio
loop = asyncio.get_event_loop()
 #通过回调函数获取 执行结果
def  call_back(future):
    print("回调结果：", future.result())
task = asyncio.ensure_future(test1())
task.add_done_callback(call_back)
loop.run_until_complete(task)   #loop，当成一个线程池用即可（但是并不是线程池）

'''运行结果如下：
1
3
4
2
回调结果： stop
'''