一:什么是协程
协程(Coroutine):,又称微线程。协程是一种用户态的轻量级线程。是由用户自己控制，CPU根本不知道协程存在。
协程拥有自己的寄存器上下文和栈。
协程调度切换时，将寄存器上下文和栈保存在其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈
因此:协程能保留上一次调用的时的状态,每次过程重入时，就相当于进入上一次调用的。
换种说法：进入上一次离开时所处逻辑流的位置。
注意：线程切换会保存到CPU的寄存器里。
协程的标准：
1）必须在只有一个单线程里实现并发
2）修改共享数据不需要加锁
3）用户程序里自己保存从个控制流的上下文栈
4）一个协程遇到IO操作自动切换到其他协程
二：协程在什么时候切换
在什么时候进程切换:遇到I/O操作就切换，协程就是把io踢掉了（因为IO耗时）。
什么时候切回去: I0操作调用完了，通过调用callback切换回去
三:协程的优点缺点
优点：
1）无需线程上下文切换的开销
2）无需原子操作锁定及同步的开销（因为协程就是单线程，它就是串行，同一时间改数据只有一个线程）
3）方便切换控制流，简化编程模型
4）高并发+高扩展性+低成本：一个CPU支持上万的协程不是问题，很适合高并发
缺点：
1）无法利用多核资源：协程本质是单线程，他不能同时单个CPU的多个核用上，协程需要和进程配合
才能运行在多CPU上。
2）进行阻塞（Blocking)操作（如IO时）会阻塞整个程序
四：yield实现切换
# -*- coding:utf-8 -*-
__author__ = 'shisanjun' import time
import queue def consumer(name):
print("------->starting eating baozi...") while True:
new_baozi=yield
print("[%s] is eating baozi %s" %(name,new_baozi)) def producer():
r=con.__next__() #con=consumer("c1")#只是生成生成器，不会执行，所以先要调用next才会开始执行
r=con2.__next__() n=0 while n <5:
n+=1
con.send(n)#两个作业，唤醒生成器，并赋值
con2.send(n) print("\033[32;1m[producer]\033[0m is making baozi %s" %n) if __name__=='__main__':
con=consumer("c1") #生成生成器
con2=consumer("c2")
p=producer() """
------->starting eating baozi...
------->starting eating baozi...
[c1] is eating baozi 1
[c2] is eating baozi 1
[producer] is making baozi 1
[c1] is eating baozi 2
[c2] is eating baozi 2
[producer] is making baozi 2
[c1] is eating baozi 3
[c2] is eating baozi 3
[producer] is making baozi 3
[c1] is eating baozi 4
[c2] is eating baozi 4
[producer] is making baozi 4
[c1] is eating baozi 5
[c2] is eating baozi 5
[producer] is making baozi 5
"""
我们刚才用yield实现一个简单的协程，实现单线程多并发。
五：Greenlet
greenlet是一个用C实现的协程模块，相比与python自带的yield，它可以使你在任意函数之间随意切换，而不需把这个函数先声明为generator
# -*- coding:utf-8 -*-
__author__ = 'shisanjun' from greenlet import greenlet def test1():
print(12)
gr2.switch()
print(34)
gr2.switch() def test2():
print(56)
gr1.switch()
print(78) gr1=greenlet(test1)#起动一个协程
gr2=greenlet(test2)
gr1.switch() #从test1开始
上面代码切换过程
没有解决一个问题，就是遇到IO操作，自动切换，手动切换。下面实现自动切换
六：Gevent
Gevent 是一个第三方库，可以轻松通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet,
它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度。
# -*- coding:utf-8 -*-
__author__ = 'shisanjun' import gevent def func1():
print("\033[31;1m 李在搞锗\033[0m")
gevent.sleep(2)#遇到sleep自动切换，模拟IO操作
print("\033[31;1m 李在又继续搞锗。。。。\033[0m") def func2():
print(("\033[32;1m 李切换搞牛。。。\033[0m"))
gevent.sleep(1)#遇到sleep自动切换
print(("\033[32;1m 李切换继续搞牛。。。\033[0m")) gevent.joinall(
[
gevent.spawn(func1),#可以带多个参数，第一个为函数名，第二个为函数参数
gevent.spawn(func2)
]
) """
李在搞锗
李切换搞牛。。。
李切换继续搞牛。。。
李在又继续搞锗。。。。
"""
七： 同步与异步的性能区别
# -*- coding:utf-8 -*-
__author__ = 'shisanjun' import gevent def task(pid):
gevent.sleep(0.5)
print('Task %s done' %pid) def synchronous():
for i in range(1,10):
task(i) def asynchronous():
theads=[gevent.spawn(task,i) for i in range(10)]
gevent.joinall(theads) print("synchronous")
synchronous() #顺序执行，结果是一个个出来
print("asynchronous")
asynchronous() #并发执行,结果几乎同时出来 """
synchronous
Task 1 done
Task 2 done
Task 3 done
Task 4 done
Task 5 done
Task 6 done
Task 7 done
Task 8 done
Task 9 done
asynchronous
Task 0 done
Task 9 done
Task 8 done
Task 7 done
Task 6 done
Task 5 done
Task 4 done
Task 3 done
Task 2 done
Task 1 done """
上面程序的重要部分是将task函数封装到Greenlet内部线程的gevent.spawn。
初始化的greenlet列表存放在数组threads中，此数组被传给gevent.joinall 函数，
后者阻塞当前流程，并执行所有给定的greenlet。执行流程只会在 所有greenlet执行完后才会继续向下走。
八：自动遇到IO切换
Gevent 默认不知道urllib，socket做了IO操作，所以打补厅，增加monkey.patch_all()
# -*- coding:utf-8 -*-
__author__ = 'shisanjun' from gevent import monkey
import gevent
from urllib.request import urlopen
#gevent默认检测不到ulrlib,所以默认是阻塞的，要加monkey实现自动切换
monkey.patch_all()#实现遇到IO就自动切换 def f(url):
print('Get %s '%url)
resp=urlopen(url)#这里自动切换了 data=resp.read()
print("%d bytes received from %s." %(len(data),data)) gevent.joinall([
gevent.spawn(f,"https://www.baidu.com"),
gevent.spawn(f,"https://www.360.cn"), ])
九：通过gevent实现单线程下的多socket并发
# -*- coding:utf-8 -*-
__author__ = 'shisanjun'
import sys
import socket
import time
import gevent from gevent import socket,monkey monkey.patch_all() def server(port):
s=socket.socket()
s.bind(("0.0.0.0",port))
s.listen(100) while True:
conn,addr=s.accept()
gevent.spawn(handle_request,conn) def handle_request(conn):
try:
while True:
data=conn.recv(1024)
print('recv:',data)
conn.send(data)
if not data:
conn.shutdown(socket.SHUT_WR)
except Exception as e:
print(e)
finally:
conn.close() if __name__=="__main__":
server(8001)
# -*- coding:utf-8 -*-
__author__ = 'shisanjun'
import socket
import threading def sock_conn(): client = socket.socket() client.connect(("localhost",8001))
count = 0
while True:
#msg = input(">>:").strip()
#if len(msg) == 0:continue
client.send( ("hello %s" %count).encode("utf-8")) data = client.recv(1024) print("[%s]recv from server:" % threading.get_ident(),data.decode()) #结果
count +=1
client.close() for i in range(100):
t = threading.Thread(target=sock_conn)
t.start() #并发100个sock连接
本文没有解决：什么时候切换回来