Python-并发编程-协程

一、什么是协程

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

注意：

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

对比操作系统控制线程的切换，用户在单线程内控制协程的切换优缺点如下：
优点：

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

缺点：

1. 协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程；
2. 协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程

总结协程特点：

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

二、引入协程使用情景

协程就是基于单线程实现并发，即只有一个CPU只用一个线程实现并发，这时我们就可以想到之前学习的并发所使用的多道技术(切换+保存状态)；

cpu正在运行一个任务，会在两种情况下切走去执行其他的任务（切换由操作系统强制控制），一种情况是该任务发生了阻塞，另外一种情况是该任务计算的时间过长或有一个优先级更高的程序替代了它；

之前说过进程的三种执行状态：运行态，阻塞态，就绪态，虽说是进程的三种执行状态，但线程才是执行单位，CPU在多个任务之间快速的切换，只为让多个任务都能执行，看起来就像同时执行一样，但是如果多个任务都是纯计算的，这种切换反而会降低效率，下面我们有yield来验证一下；
yield：

1. yiled可以保存状态，yield的状态保存与操作系统的保存线程状态很像，但是yield是代码级别控制的，更轻量级
2. send可以把一个函数的结果传给另外一个函数，以此实现单线程内程序之间的切换;

案例：纯计算验证切换降低效率

串行执行
def func1():
    for i in range(100000000):
        i += 1


def func2():
    for i in range(100000000):
        i += 1

if __name__ == '__main__':
    ctime = time.time()
    func1()
    func2()
    print(time.time() - ctime)  # 7s多一些

# 通过yield，实现保存状态加切换（自定义的切换，并不是遇到io才切，所有它并不能节约时间）
# 单纯的切换，不但不会提高效率，反而会讲低效率
def func1():
    for i in range(100000000):
        i += 1
        yield


def func2():
    g=func1() # 先执行一下func1
    for i in range(100000000):
        i += 1
        next(g) # 回到func1执行


if __name__ == '__main__':
    ctime = time.time()
    func2()
    print(time.time() - ctime) #14.764776706695557

对于单线程下，我们不可避免程序中出现io操作，但如果我们能在自己的程序中（即用户程序级别，而非操作系统级别）控制单线程下的多个任务能在一个任务遇到io阻塞时就切换到另外一个任务去计算，这样就保证了该线程能够最大限度地处于就绪态，即随时都可以被cpu执行的状态，相当于我们在用户程序级别将自己的io操作最大限度地隐藏起来，从而可以迷惑操作系统，让其看到：该线程好像是一直在计算，io比较少，从而更多的将cpu的执行权限分配给我们的线程。

协程的本质就是在单线程下，由用户自己控制一个任务遇到io阻塞了就切换另外一个任务去执行，以此来提升效率。

我们且需要解决以下问题
可以控制多个任务之间的切换，切换之前将任务的状态保存下来，以便重新运行时，可以基于暂停的位置继续执行，可以检测io操作，在遇到io操作的情况下才发生切换；

三、greenlet、gevent、asyncio

3.1 greenlet

from greenlet import greenlet
import time
# 遇到io不会切，初级模块，gevent模块基于它写的，处理io切换
def eat():
    print('我吃了一口')
    time.sleep(1)
    # p.switch()
    print('我又吃了一口')
    # p.switch()


def play():
    print('我玩了一会')
    e.switch()
    print('我又玩了一会')


if __name__ == '__main__':
    e = greenlet(eat)
    p = greenlet(play)
    e.switch()

3.2 gevent

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

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

g2=gevent.spawn(func2)

g1.join() #等待g1结束

g2.join() #等待g2结束

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

g1.value#拿到func1的返回值

# 以后使用,这一句必须写
from gevent import monkey;monkey.patch_all()
import gevent
import time

def eat(name):
    print('%s 吃了一口' % name)
    time.sleep(1)  # io操作，被猴子补丁替换之后，gevent.sleep()
    print('%s 又吃了一口' % name)


def play(name):
    print('%s 玩了一会' % name)
    time.sleep(2)
    print('%s 又玩了一会' % name)


if __name__ == '__main__':
    ctim = time.time()
    e = gevent.spawn(eat,'lqz')
    p = gevent.spawn(play,'lqz')
    e.join() # 等待e执行完成
    p.join()
    print('主')
    print(time.time() - ctim)  #2.0165154933929443

3.3 asyncio

# 官方支持协程的库
import time
import asyncio

# 把普通函数变成协程函数
# 3.5以前这么写
@asyncio.coroutine
def task():
    print('开始了')
    yield from asyncio.sleep(1)  #asyncio.sleep(1)模拟io
    print('结束了')


loop=asyncio.get_event_loop()  # 获取一个时间循环对象#

# 协程函数加括号，并不会真正的去执行，它需要提交给loop，让loop循环着去执行
# 协程函数列表

ctime=time.time()
t=[task(),task()]
loop.run_until_complete(asyncio.wait(t))
loop.close()
print(time.time()-ctime)



import time
import asyncio
from threading import current_thread
# 表示我是协程函数,等同于3.5之前的装饰器
async def task():
    print('开始了')
    print(current_thread().name)
    await asyncio.sleep(3)  # await等同于原来的yield from
    print('结束了')

async def task2():
    print('开始了')
    print(current_thread().name)
    await asyncio.sleep(2)
    print('结束了')

loop=asyncio.get_event_loop()

ctime=time.time()
t=[task(),task2()]
loop.run_until_complete(asyncio.wait(t))
loop.close()
print(time.time()-ctime)

其他：

补充虚拟环境

1 解决不同项目依赖的模块版本不同的问题
2 pycharm中创建项目时选择
   -这个虚拟环境可不可以给其他项目使用（取决你是否选择）
    -基于系统解释器当前状态还是纯净状态来创建虚拟环境
3 装模块：
   -cmd窗口下：pip3 install flask   （装在谁下，你一定要确认好）
    -推荐你们用pycharm：setting---》那一套
    -pycharm下的terminal下装（相当于cmd），比cmd好在，它有个提示
4 现在用了虚拟环境如何换到系统环境
    
4 环境变量的作用
   -把一个路径加入到环境变量，以后该路径下的命令，可以再任意位置执行

猴子补丁补充：
class Monkey():
    def play(self):
        print('猴子在玩')


class Dog():
    def play(self):
        print('狗子在玩')
m=Monkey()
m.play()

m.play=Dog().play  # 这个过程就叫猴子补丁，在程序运行过程中，动态修改
m.play()


import json
import ujson

def monkey_patch_json():
    json.__name__ = 'ujson'
    json.dumps = ujson.dumps
    json.loads = ujson.loads
monkey_patch_json()


# 其实用的是ujson
aa=json.dumps({'name':'lqz','age':19})
print(aa)