上一节课我们知道GIL锁导致CPython中多线程无法并行执行，之能给并发
并发实现的原理就是切换+保存--->意味着使用多线程实现并发，就需要为每一个任务创建一个线程，必然增加了线程创建销毁与切换带来的开销
面临的问题：高并发情况下，由于任务数量太多导致无法开启新的线程，使得既没有实际任务要执行，也无法创建新的线程来处理新的情况
解决问题：既要保证并发效果，然后想办法避免创建线程开销问题
||||||||||||||||||||||||||||||||||||
由此带来协程，其原理是使用单线程来实现多任务并发
一，单线程实现并发
并发：指的是多个任务同时发生，看起来同时在进行
并行：多个任务真正的同时进行
早期的计算机只有一个CPU，既然CPU可以切换线程来实现并发，那么线程中也可以切换任务实现
如何实现：
并发=切换任务+保存状态，只要找到一种方案，能够在两个任务之间切换执行并且保存状态，那就可以实现单线程并发
python中生成器就具备这样一个特点，每次调用next都会回到生成器函数中执行代码，意味着任务之间可以切换，并且是基于上次运行的结果，意味着生成器会自动保存执行状态！
def task1():
while True:
yield
print('task 1 run ')
def task2():
g=task1()
while True:
next(g)
print('task 2 run')
task2()
虽然并发是实现了，但是效率问题和串行无异同
#两个计算任务，一个采用生成器切换并发执行，一个直接串行调用
import time
def task1():
a=0
for i in range(10000000):
a+=i
yield
def task2():
g=task1()
b=0
for i in range(10000000):
b+=1
next(g)
s=time.time()
task2()
print(time.time()-s)
#3.1465859413146973
# 单线程下串行执行两个计算任务 效率反而比并发高 因为并发需要切换和保存
import time
def task1():
a=0
for i in range(10000000):
a+=i
def task2():
b=0
for i in range(10000000):
b+=1
s=time.time()
task1()
task2()
print(time.time()-s)
#1.6338098049163818
可以看到对于纯计算任务而言，单线程并发反而使执行效率下降了一半左右，所以这样的方案对于纯计算任务而言是没有必要的
greenlet模块实现并发
上述代码中，使用yield来切换使用的代码非常混乱，若任务数庞大，不敢想象，因此专门对yield进行了封装，此便是greenlet模块
from greenlet import greenlet
def eat(name):
print('%s eat 1' %name)
g2.switch('jack')
print('%s eat 2'%name)
g2.switch()
def play(name):
print('%s play 1'%name)
g1.switch()
print('%s play 2')
g1=greenlet(eat)
g2=greenlet(play)
#g1.switch('rose')可以在第一次switch时传入参数，一次就够了
虽然上述greenlet模块简化了yield复杂的代码结构，实现了单线程下多任务并发
但是无论直接使用yield还是greenlet都不能检测到io操作，同样遇到了还是阻塞，同样的对于纯计算机任务而言效率是没有任何提升的
切换
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只是提供了一种比generator更加便捷的切换方式，当切换到一个任务执行时如果遇到io，那就原地阻塞，任然是没有解决遇到io自动切换来提升效率的问题
通常的任务代码通常既有计算操作，又有阻塞操作。那我们就会这么想可以在执行任务1时候遇到阻塞，那就让这个阻塞时间利用去执行任务2.。能达到这个效率--->Gevent模块
二，协程
协程：是单线程下的并发，又称微线程
英文名：Coroutine 是一种用户态的轻量化线程，即协程是用户自己控制调度的
1，PYTHON的线程属于内核级别的，即由操作系统控制调度（如单线程遇到io或执行时间过长就会被迫交出cpu执行权，切换到其他线程运行
2，但线程内开启协程，一旦遇到io，就会从应用程序级别（非操作系统）控制切换，从此来提升效率(非io操作的切换与效率无关)
对比操作系统控制线程的切换，用户在单线程内控制协程的切换有以下
优点：
==1，协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
==2，单线程内就可以实现并发的效果，最大限度的利用cpu
缺点：
** 1，协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程尽可能提高效率
** 2，写成的本质是单个线程，一旦协程出现阻塞，将会阻塞整个线程
gevent 模块
定义：是一个第三方库，可以轻松通过gevent实现并发编程，在gevent中主要模式是‘Greenlet’，它是以C扩展模式形式接入Python的轻量级协程
greenlet全部运行在主程序操作系统进程的内部，但他们被协作式地调度
常用方法：
#用法
#创建一个协程对象 g1
g1 =gevent.spawn(func,1,2,3,x=4,y=5)
#spawn括号内第一个参数就是函数名，如果eat，后面可以有多个参数，可以是位置参数，或者关键字参数，都是传给函数eat的
g2=gevent.spawn(func2)
g1.join() #等待g1结束
g2.join() #等待g2结束
或者上述两步合作一步：
gevent.joinall([g1,g2])
g1.value #拿到func1 的返回值
#遇到io阻塞时会自动切换任务
import gevent,sys
from gevent import monkey #导入monkey补丁
monkey.patch_all() #打补丁
import time
print(sys.path)
def task1():
print('task1 run')
time.sleep(3)
print('task 1 over')
def task2():
print('task2 run')
time.sleep(1)
print('task2 over')
g1=gevent.spawn(task1)
g2=geven.spawn(task2)
# gevent.joinall([g1,g2])
g1.join()
g2.join()
# 执行以上代码会发现不会输出任何消息
# 这是因为协程任务都是以异步方式提交，所以主线程会继续往下执行，而一旦执行完最后一行主线程也就结束了，
# 导致了协程任务没有来的及执行，所以这时候必须join来让主线程等待协程任务执行完毕 也就是让主线程保持存活
# 后续在使用协程时也需要保证主线程一直存活，如果主线程不会结束也就意味着不需要调用join
'需要注意'
1如果主线程结束了，协程任务也会立即结束
2monkey补丁的原理是把原始的阻塞方法替换为修改后非阻塞方法，来实现io自动切换
++3必须在打补丁后在使用相应的功能，避免忘记，写在最上方++