python-协程

协程介绍

协程：是单线程下的并发，又称微线程，纤程。英文名Coroutine。一句话说明什么是线程：协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的。

并发本质:切换加保存状态

下面我们用协程来实现同一线程下切换加保存状态.

需要强调的是：

#1. python的线程属于内核级别的，即由操作系统控制调度（如单线程遇到io或执行时间过长就会被迫交出cpu执行权限，切换其他线程运行）
#2. 单线程内开启协程，一旦遇到io，就会从应用程序级别（而非操作系统）控制切换，以此来提升效率（！！！非io操作的切换与效率无关）

对比操作系统控制线程的切换，用户在单线程内控制协程的切换

优点如下：

#1. 协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
#2. 单线程内就可以实现并发的效果，最大限度地利用cpu

总结协程特点：

1. 必须在只有一个单线程里实现并发
2. 修改共享数据不需加锁
3. 用户程序里自己保存多个控制流的上下文栈
4. 附加：一个协程遇到IO操作自动切换到其它协程（如何实现检测IO，yield、greenlet都无法实现，就用到了gevent模块（select机制））

Greenlet模块

安装 ：pip3 install greenlet

from greenlet import greenlet
import time
# greenlet 只是可以实现一个简单的切换功能，还是不能做到遇到IO就切换
# g1 = greenlet(func)   实例化一个对象
# g1.switch()  用这种方式去调用func函数
# 当使用switch调用func的时候，什么时候func会停止运行？
#   1 要么return      2 要么在func内部又遇到 switch

def eat(name):
    print('%s吃炸鸡'%name)
    time.sleep(2)
    f2.switch('小雪2')
    print('%s吃雪糕'%name)
    f2.switch()

def drink(name):
    print('%s喝啤酒'%name)
    f1.switch()
    print('%s喝可乐'%name)


f1 = greenlet(eat)
f2 = greenlet(drink)
f1.switch('小雪')

单纯的切换（在没有io的情况下或者没有重复开辟内存空间的操作），反而会降低程序的执行速度

#顺序执行
import time
def f1():
    res=1
    for i in range(100000000):
        res+=i

def f2():
    res=1
    for i in range(100000000):
        res*=i

start=time.time()
f1()
f2()
stop=time.time()
print('run time is %s' %(stop-start)) #10.985628366470337

#切换
from greenlet import greenlet
import time
def f1():
    res=1
    for i in range(100000000):
        res+=i
        g2.switch()

def f2():
    res=1
    for i in range(100000000):
        res*=i
        g1.switch()

start=time.time()
g1=greenlet(f1)
g2=greenlet(f2)
g1.switch()
stop=time.time()
print('run time is %s' %(stop-start)) # 52.763017892837524

效率对比

greenlet当切到一个任务执行时如果遇到io，那就原地阻塞，仍然是没有解决遇到IO自动切换来提升效率的问题。

单线程里的这20个任务的代码通常会既有计算操作又有阻塞操作，我们完全可以在执行任务1时遇到阻塞，就利用阻塞的时间去执行任务2。。。。如此，才能提高效率，这就用到了Gevent模块。

Gevent模块

安装：pip3 install gevent

Gevent 是一个第三方库，可以轻松通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度。

方法介绍

g1=gevent.spawn(func,1,,2,3,x=4,y=5)创建一个协程对象g1
spawn括号内第一个参数是函数名，后面可以有多个参数，可以是位置实参或关键字实参，都是传给函数func的

g2=gevent.spawn(func2)

g1.join() #等待g1结束

g2.join() #等待g2结束

或者上述两步合作一步：gevent.joinall([g1,g2])

g1.value  #拿到func1的返回值

.

import gevent
import time
# gevent 可以实现  当函数中遇到io操作时，就自动的切换到另一个函数
# g1 = gevent.spawn(func,参数)
# gevent.join(g1) 让func执行完毕
# gevent.joinall([g1,g2,g3,g4])
#    func停止的原因: 1 func执行完了     2 遇到IO操作了

# def func1():
#     print('1 2 3 4')
#     # gevent.sleep(1)
#     time.sleep(1)
#     print('3 2 3 4')
#     # gevent.sleep(1)
#
# def func2():
#     print('2 2 3 4')
#     # gevent.sleep(1)
#     time.sleep(1)# gevent不能识别其他的IO操作，只能识别自己认识的IO
#     print('再来一次')
#
# g1 = gevent.spawn(func1)
# g2 = gevent.spawn(func2)
# g1.join()# 等待g1指向的任务执行结束

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

##  以下解决gevent不能识别其他IO操作的事情
from gevent import monkey
monkey.patch_all()# 可以让gevent识别大部分常用的IO操作
import time

def func1():
    print('1 2 3 4')
    time.sleep(1)
    print('3 2 3 4')
    # gevent.sleep(1)

def func2():
    print('2 2 3 4')
    time.sleep(1)
    print('再来一次')

g1 = gevent.spawn(func1)
g2 = gevent.spawn(func2)
g1.join()# 等待g1指向的任务执行结束
g2.join()

串行和并发的效率对比

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

def func1(num):
    time.sleep(1)
    print(num)

start = time.time()
for i in range(10):
    func1(i)
print(time.time() - start)


start = time.time()
l = []
for i in range(10):
    g = gevent.spawn(func1,i)
    l.append(g)
gevent.joinall(l)
print(time.time() - start)

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

def get_result(url):# 任务函数
    res = requests.get(url)
    print(url,res.status_code,len(res.text))

url_l = ['http://www.baidu.com',
         'https://www.jd.com',
         'http://www.apache.com',
         'http://www.taobao.com',
         'http://www.qq.com',
         'http://www.mi.com',
         'http://www.cnblogs.com']

def sync_func(url_l):
    '''同步调用'''
    for url in url_l:# 串行执行任务函数
        get_result(url)

def async_func(url_l):
    '''异步'''
    l = []
    for url in url_l:
        g = gevent.spawn(get_result,url)# 使用gevent，协程去并发实现执行任务函数
        # 当遇见请求某个网页发生比较大的网络延迟（IO），马上会切换到其他的任务函数
        l.append(g)
    gevent.joinall(l)# 等待所有任务函数执行结束

start = time.time()
sync_func(url_l)
print('sync:',time.time() - start)

start = time.time()
async_func(url_l)
print('async:',time.time() - start)

总结:

• 计算密集用多进程，可以充分利用多核cpu的性能，

• IO密集用多线程（注意，协程是在单线程的）

• 多线程和协程的区别是：

• 线程是由操作系统调度，控制

• 协程是由程序员自己调度，控制