协程介绍
在单线程执行的情况下，如果要实现并发的效果，只需要CPU在不同的时间运行不同的线程即可。
- yield 可以保存状态，yield的状态保存于操作系统的保存线程状态很像，但是yield 是代码级别控制的，更轻量级。
- send可以把一个函数的结果传给另一个函数，以此实现单线程内程序之间的切换。
在单线程下，程序不可避免的会出现IO操作，如果我们在自己的程序中（用户程序级别，而非操作系统级别）控制单线程下的多个任务在遇到IO操作时，自动切换为另一个任务去执行计算，就最大程度的保证线程随时都是可以被CPU执行的状态，这样操作系统就认为该线程一直在执行计算任务，IO任务很少，从而将更多的CPU资源分配给线程。
协程的本质
在单线程下，用户自己控制一个任务遇到IO阻塞就切换到另一个任务去执行，以此来提升效率。
为了实现这种方式，我们需要寻找同时满足以下条件的解决方案：
- 可以控制多个任务之间的切换，切换之前将任务保存下来。以便重新运行，可以基于暂停的位置继续运行。
- 可以检测到IO操作，在遇到io操作的情况下才发生切换。
协程是单线程下的并发，又称微线程。协程是一种用户态的轻量级线程，是由用户自己控制调度的。
- python的线程属于内核级别的，即由操作系统控制调度（如单线程遇到io或执行时间过长就会被迫交出cpu执行权限，切换其他线程运行）
- 单线程内开启协程，一旦遇到io，就会从应用程序级别（而非操作系统）控制切换，以此来提升效率（！！！非io操作的切换与效率无关）
协程的特点
优点如下：
- 协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
- 单线程内就可以实现并发的效果，最大限度地利用cpu
缺点如下：
- 协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程
- 协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程
总结协程的特点：
1.必须在只有一个单线程里实现并发。
2.修改和共享数据不需要加锁
3.用户程序里自己保存多个控制流的上下文栈
4.一个协程遇到IO操作自动切换到其它协程（如何实现检测IO，yield、greenlet都无法实现，就用到了gevent模块（select机制））
Greenlet 模块
安装模块
pip3 install greenlet
Greenlet模块主要用于实现同一个线程中不同任务之间的来回切换，这里切换时认为控制的，Greenlet并不能实现遇到IO之后自动切换。
实现代码如下：
from greenlet import greenlet
def eat(name):
print('%s eat 1 ' % name)
g2.switch('tom') # 将任务切换到g2，也就是paly函数进行执行
print('%s eat 2 ' % name)
g2.switch() # 再次将任务切回g2
def play(name):
print('%s play 1' % name)
g1.switch() # 将任务切回g1
print('%s play 2' % name)
g1 = greenlet(eat) # 生成一个greenlet对象
g2 = greenlet(play)
g1.switch('bob') # 启动任务 eat
输出结果：
bob eat 1
tom play 1
bob eat 2
tom play 2
gevent模块
gevent 模块可以实现遇到IO之后自动进行切换，在使用之前需要安装gevent
pip3 install gevent
gevent模块的使用
使用gevent模块，在遇到gevent.sleep时自动切换,这里只限于gevent方法：
import gevent # 导入Gevent模块
import time
def eat(name):
print('%s eat 1 ' % name)
gevent.sleep(2)
print('%s eat 2 ' % name)
def play(name):
print('%s play 1' % name)
gevent.sleep(2)
print('%s play 2' % name)
g1=gevent.spawn(eat,'tom')
g2=gevent.spawn(play,'bob')
# g1.join()
# g2.join()
gevent.joinall([g1,g2])
输出结果：
tom eat 1
bob play 1
tom eat 2
bob play 2
gevent模块识别其他IO
通过对gevent模块打补丁，可以扩展其识别其他的IO行为，这种方式才是经常使用的方式：
from gevent import monkey;monkey.patch_all() # 给Gevent模块打补丁，让它能识别其他的IO操作
import gevent # 导入Gevent模块
import time
def eat(name):
print('%s eat 1 ' % name)
# gevent.sleep(2)
time.sleep(2) # 导入补丁之后可以识别time模块中的sleep行为
print('%s eat 2 ' % name)
def play(name):
print('%s play 1' % name)
# gevent.sleep(2)
time.sleep(2)
print('%s play 2' % name)
g1=gevent.spawn(eat,'tom')
g2=gevent.spawn(play,'bob')
# g1.join()
# g2.join()
gevent.joinall([g1,g2])
单线程内实现并发
使用单线程的方式实现客户端和服务端的交互：
# 服务端
from gevent import monkey,spawn;monkey.patch_all()
from socket import *
from threading import Thread,current_thread
def comunicate(conn):
print('子线程: %s' %current_thread().getName())
while True:
try:
data = conn.recv(1024)
if not data: break
conn.send(data.upper())
except ConnectionResetError:
break
conn.close()
def server(ip,port):
print('主线程：%s' %current_thread().getName())
server = socket(AF_INET,SOCK_STREAM)
server.bind((ip,port))
server.listen(5)
while True:
conn,addr = server.accept()
print(addr)
spawn(comunicate,conn)
server.close()
if __name__=='__main__':
g=spawn(server,'127.0.0.1',8080)
g.join()
# 客户端
from socket import *
from threading import current_thread,Thread
def client():
client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8080))
while True:
client.send(('%s say hello' %current_thread().getName()).encode('utf-8'))
data=client.recv(1024)
print(data.decode('utf-8'))
client.close()
if __name__ == '__main__':
for i in range(500): # 使用500个线程并发请求服务端
t=Thread(target=client)
t.start()
