并发编程 - 协程 - 1.协程概念/2.greenlet模块/3.gevent模块/4.gevent实现并发的套接字通信

1.协程
并发：切+保存状态
单线程下实现并发：协程  切+ 保存状态  yield
    遇到io切，提高效率
    遇到计算切，并没有提高效率

    检测单线程下 IO行为 io阻塞 切
     相当于骗操作系统 一直处于计算
协程：。。。
单线程下实现并发：根本目标：遇到IO就切，一个线程的整体IO降下来
程序用的cpu 时间长，就叫执行效率高
效率最高：多个进程  （多个cpu）
          每个进程开多个线程
          每个线程用到协程 （IO就切）
总结协程特点：

 #并发执行
 import time

 def producer():
     g=consumer()
     next(g)
     for i in range(10000000):  # 计算
         g.send(i)

 def consumer():
     while True:
         res=yield

 start_time=time.time()
 producer()
 stop_time=time.time()
 print(stop_time-start_time)

 #串行
 import time

 def producer():
     res=[]
     for i in range(10000000):
         res.append(i)
     return res

 def consumer(res):
     pass

 start_time=time.time()
 res=producer()
 consumer(res)
 stop_time=time.time()
 print(stop_time-start_time)

2.greenlet模块
pip3 install greenlet
 greenlet:可以很方便的切 但不能检测到 遇到IO 切
 greenlet 比yield 好 但是还是不好 遇到io不会切

 from greenlet import greenlet
 import time

 def eat(name):
     print('%s eat 1' %name)
     time.sleep(10)  # 遇到io 不会立即切
     g2.switch('egon')
     print('%s eat 2' %name)
     g2.switch()

 def play(name):
     print('%s play 1' %name )
     g1.switch()
     print('%s play 2' %name )

 g1=greenlet(eat)
 g2=greenlet(play)

 g1.switch('egon') # 第一次切 需要传参数

3.gevent模块
pip3 install gevent
gevent：封装了greenlet模块，但是他能检测到io 自动切
    只能检测到gevent.sleep() gevent的IO阻塞
    加上补丁后，就可以检测到所有的IO 原理是：将阻塞变为非阻塞
    from gevent import monkey;monkey.patch_all()
这种形式的协程 才能帮我们提升效率 从始至终 就一个线程
gevent.joinall([g1,g2])   等待全部执行完

gevent 模块：监测单线程下多个任务得IO行为实现遇到IO就自动切到另一个任务去执行
     提升单线程运行效率
     应用场景：单线程下多个任务io密集型
ftp io密集型 线程来回切 比os q切 小路高

 from gevent import monkey;monkey.patch_all()  # 一定要放在程序的开头 检测所以的io 将阻塞变成非阻塞
 import gevent
 import time

 def eat(name):
     print('%s eat 1' % name)
     time.sleep(3)  # 7s多一些 gevent 只识别 gevent 的 io操作
     # gevent.sleep(3)  # 4s 多一些
     print('%s eat 2' % name)

 def play(name):
     print('%s play 1' % name)
     time.sleep(4)
     # gevent.sleep(4)
     print('%s play 2' % name)

 start_time=time.time()
 g1=gevent.spawn(eat,'egon')
 g2=gevent.spawn(play,'alex')

 g1.join()
 g2.join()
 stop_time=time.time()
 print(stop_time-start_time)
 """
 egon eat 1
 alex play 1
 egon eat 2
 alex play 2
 4.001747369766235

 """
 """
 egon eat 1
 egon eat 2
 alex play 1
 alex play 2
 7.0017828941345215
 """
 """
 egon eat 1
 alex play 1
 egon eat 2
 alex play 2
 4.001675367355347
 """

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

 def eat(name):
     print('%s eat 1' % name)
     time.sleep(3)
     print('%s eat 2' % name)

 def play(name):
     print('%s play 1' % name)
     time.sleep(4)
     print('%s play 2' % name)

 g1=gevent.spawn(eat,'egon')  # 异步操作
 g2=gevent.spawn(play,'alex')

 # time.sleep(5)  # 得等到 全部执行完

 # g1.join()  # 等到 全部执行完
 # g2.join()

 gevent.joinall([g1,g2])  # 等到g1 g2 全部执行完
 """
 egon eat 1
 alex play 1
 egon eat 2
 alex play 2
 """

4.gevent实现并发的套接字通信
# 500 客户端同时 登录  服务端：这里1个线程 抗住了 500个client
 # 这里也说明了：单线程下面io问题降下来，效率大幅度提高

  说明
      使用：多进程
            多线程
            一个线程io 问题解决了 效率大大得提高
服务端：

 #基于gevent实现
 from gevent import monkey,spawn;monkey.patch_all()
 from socket import *

 def communicate(conn):
     while True:
         try:
             data=conn.recv(1024)
             if not data:break
             conn.send(data.upper())
         except ConnectionResetError:
             break

     conn.close()

 def server(ip,port):
     server = socket(AF_INET, SOCK_STREAM)
     server.bind((ip,port))
     server.listen(5)

     while True:
         conn, addr = server.accept()
         spawn(communicate,conn)  # 这里没必要加join

     server.close()

 if __name__ == '__main__':
     g=spawn(server,'127.0.0.1',8090)
     g.join()

客户端：

 from socket import *
 from threading import Thread,currentThread

 def client():  #
     client=socket(AF_INET,SOCK_STREAM)
     client.connect(('127.0.0.1',8090))

     while True:
         client.send(('%s hello' %currentThread().getName()).encode('utf-8'))
         data=client.recv(1024)
         print(data.decode('utf-8'))

     client.close()

  # 500 客户端同时 登录  服务端：这里1个线程 抗住了 500个client
  # 这里也说明了：单线程下面io问题降下来，效率大幅度提高
 if __name__ == '__main__':
     for i in range(500):  # 500 客户端同时 登录  服务端：这里1个线程 抗住了 500个client
         t=Thread(target=client)
         t.start()