python大佬养成计划----协程

协程，又称微线程，纤程。英文名Coroutine
协程看上去也是子程序，但执行过程当中，在子程序内部可中断，而后转而执行别的子程序，在适当的时候再返回来接着执行。

最大的优点就是协程极高的执行效率。由于子程序切换不是线程切换，而是由程序自身控制，所以，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优点就越明显。
第二大优点就是不须要多线程的锁机制，由于只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只须要判断状态就行了，因此执行效率比多线程高不少。
由于协程是一个线程执行，那怎么利用多核CPU呢？最简单的方法是多进程+协程，既充分利用多核，又充分发挥协程的高效率，可得到极高的性能。

yield实现协程

Python对协程的支持还很是有限，用在generator中的yield能够必定程度上实现协程。虽然支持不彻底，但已经能够发挥至关大的威力了。

import threading
import time
def producer(c):
    c.__next__()
    n=0
    while n<5:
        n+=1
        print('[生产者]产出第%s条数据' %(n))
        res = c.send(n)
        print('[返回]:%s' %(res))
def consumer():
    r='sheenstar'
    while True:
        # 更新r值: r = 'This is ok!', c.__next__()
        # n= yield r --> c.send(n) --> n更新
        n = yield r
        if not n:
            break
        print('[消费者]正在调用第%s条数据' %(n))
        time.sleep(1)
        r = 'This is ok!'

if __name__=='__main__':
    print(threading.current_thread())   
    print(threading.active_count())     #查看当前进行的线程
    c = consumer()
    producer(c)     #函数中有yield， 返回值为生成器;
    print(threading.active_count()) #1

gevent库实现协程

Python经过yield提供了对协程的基本支持，可是不彻底。而第三方的gevent为Python提供了比较完善的协程支持。

gevent是第三方库，经过greenlet实现协程，其基本思想是：
当一个greenlet遇到IO操做时，好比访问网络，就自动切换到其余的greenlet，等到IO操做完成，再在适当的时候切换回来继续执行。因为IO操做很是耗时，常常使程序处于等待状态，有了gevent为咱们自动切换协程，就保证总有greenlet在运行，而不是等待IO。

因为切换是在IO操做时自动完成，因此gevent须要修改Python自带的一些标准库，这一过程在启动时经过monkey patch完成。

假设多协程执行的任务， 没有IO操做或者等待， 那么协程间是依次运行， 而不是交替运行;
假设多协程执行的任务， IO操做或者等待， 那么协程间是交替运行;

#没有等待
import gevent
from gevent import monkey
monkey.patch_all()
def job(n):
    for i in range(n):
        print(gevent.getcurrent(),i)

def mian():
    g1 = gevent.spawn(job,1)
    g2 = gevent.spawn(job,2)
    g3 = gevent.spawn(job,3)
    gevent.joinall([g1,g2,g3])
    print('协程执行任务结束...')

if __name__=="__main__":
    mian()

"""
#有等待
import time
from gevent import  monkey
monkey.patch_all()

import  gevent
def job(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        time.sleep(1)

def main1():
    # 建立三个协程， 并让该协程执行job任务
    g1 = gevent.spawn(job, 2)
    g2 = gevent.spawn(job, 3)
    g3 = gevent.spawn(job, 2)
    # 等待全部的协程执行结束， 再执行主程序；
    gevent.joinall([g1, g2, g3])
    print("任务执行结束.....")

main1()

协程与线程

作一个关于协程和线程花费时间的对比实验，不具备参考性 。

import time
import gevent   #导入协程
from gevent import monkey
from urllib.request import urlopen  #链接网络
from mytimeit import timeit #导入计算时间的装饰器
from concurrent.futures import ThreadPoolExecutor   #导入线程池

def get_len_url(url):
    with urlopen(url) as u_conn:
        data = u_conn.read()
#       print('%s该网页共%s字节' %(url,len(data)))
urls = ['http://httpbin.org', 'http://example.com/']*100

@timeit
def coroutineall():
    gevents = [gevent.spawn(get_len_url,url) for url in urls]
    gevent.joinall(gevents)

@timeit
def threadall():
    with ThreadPoolExecutor(max_workers=100) as thpool:
        thpool.map(get_len_url,urls)
if __name__=="__main__":
    coroutineall()
    threadall()