python中的协程

协程

协程：是单线程下的并发，又称微线程，纤程。英文名Coroutine。

一句话说明什么是线程：协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的。

协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），每次过程重入时，就相当于进入上一次调用的状态，换种说法：进入上一次离开时所处逻辑流的位置。

注意：
　　1. python的线程属于内核级别的，即由操作系统控制调度（如单线程一旦遇到io就被迫交出cpu执行权限，切换其他线程运行）
　　2. 单线程内开启协程，一旦遇到io，从应用程序级别（而非操作系统）控制切换
协程优点：
　　1.  协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
　　2. 单线程内就可以实现并发的效果，最大限度地利用cpu
协程缺点：
　　1.协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程
　　2.协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程

yield实现协程并发

import time
def consumer():
    r=''
    while True:
        n=yield r
        if not n:
            return
        print('[CONSUMER] ←← Consuming %s...' % n)
        time.sleep(1)
        r='200 Ok'

def produce(c):
    next(c) #1.启动生成器
    n=0
    while n < 5:
        n=n+1
        print('[PRODUCER] →→ Producing %s...' % n)
        cr=c.send(n)    
        #2.将n传入到consumer的对象，yield接收到传入值开始执行代码，遇到yield执行代码返回r的值
        print('[PRODUCER] Consumer return: %s' % cr)
    #3.produce没有值了，关闭整个过程
    c.close()

if __name__ == '__main__':
    c=consumer()    #生成生成器对象
    produce(c)      #执行调用

greenlet框架实现协程（封装yield的基础库）
greenlet机制的主要思想是：生成器函数或者协程函数中的yield语句挂起函数的执行，直到稍后使用next()或send()操作进行恢复为止。可以使用一个调度器循环在一组生成器函数之间协作多个任务。greentlet是python中实现我们所谓的"Coroutine(协程)"的一个基础库。

示例1：

from greenlet import  greenlet
def foo():
    print('ok1')
    g2.switch() #阻断
    print('ok3')
    g2.switch()
def bar():
    print('ok2')
    g1.switch()
    print('ok4')

g1=greenlet(foo)    #生成foo函数的greenlet对象
g2=greenlet(bar)    #生成bar函数的greenlet对象
g1.switch() #1、执行g1对象，打印ok1
            #2、遇到g2.switch()，转到g2执行打印ok2
            #3、遇到g1.switch(),转到g1的阻断处继续执行打印ok3
            #4、遇到g2.switch()，转到g2执行打印ok4

示例2：

def eat(name):
    print('%s eat food 1' %name)
    gr2.switch('bob')
    print('%s eat food 2' %name)
    gr2.switch()
def play_phone(name):
    print('%s play 1' %name)
    gr1.switch()
    print('%s play 2' %name)

gr1=greenlet(eat)
gr2=greenlet(play_phone)
gr1.switch(name='natasha')#可以在第一次switch时传入参数，以后都不需要

这种方法不会节省时间，因为不是io操作，而greenlet遇到io操作不会跳转，仍然要io阻断
基于greenlet框架的高级库gevent模块
gevent是第三方库，通过greenlet实现协程，其基本思想是：
当一个greenlet遇到IO操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO。
由于切换是在IO操作时自动完成，所以gevent需要修改Python自带的一些标准库，这一过程在启动时通过monkey patch完成：

简单示例：

import gevent
def foo():
    print('ok1')
    gevent.sleep(4) #模拟io操作
    print('ok3')
def bar():
    print('ok2')
    gevent.sleep(2)
    print('ok4')

g1=gevent.spawn(foo)
g2=gevent.spawn(bar)
gevent.joinall([g1,g2]) #全部阻塞，或者单独一个个join

spawn括号内第一个参数是函数名，如foo，后面可以有多个参数，可以是位置实参或关键字实参，都是传给函数foo的
注意：
gevent.sleep(4)模拟的是gevent可以识别的io阻塞,

而time.sleep(2)或其他的阻塞,gevent是不能直接识别的需要用下面一行代码,打补丁,就可以识别了

1 #补丁
2 from gevent import monkey
3 monkey.patch_all(

必须放到被打补丁者的前面，如time，socket模块之前
或者我们干脆记忆成：要用gevent，需要将补丁放到文件的开头

爬虫示例：

from gevent import monkey;monkey.patch_all()
import gevent
import requests
import time

def get_page(url):
    print('GET: %s' %url)
    response=requests.get(url)
    if response.status_code == 200:
        print('%d bytes received from %s' %(len(response.text),url))


start_time=time.time()
gevent.joinall([
    gevent.spawn(get_page,'https://www.python.org/'),
    gevent.spawn(get_page,'https://www.yahoo.com/'),
    gevent.spawn(get_page,'https://github.com/'),
])
stop_time=time.time()
print('run time is %s' %(stop_time-start_time)) 

转自：https://www.cnblogs.com/lidagen/p/7252285.html