协程
参考链接： https://www.cnblogs.com/Eva-J/articles/8324673.html
协程：是单线程下的并发，又称微线程，纤程。英文名Coroutine。一句话说明什么是协程：
协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的。
协程是什么？
def 协程1():
pass
def 协程2():
pass
def 协程3():
pass
def 协程n():
pass
while 1:
协程1()
协程2()
协程3()
协程n()
协程就是一个个函数，然后死循环调用，
以上就是协程的基本思想。没什么神秘的~
需要配合异步IO使用，避免阻塞~
Greenlet模块
开启一个协程
from greenlet import greenlet def eat(name): print('%s 吃 1' % name) g2.switch('Mark') print('%s 吃 2' % name) g2.switch('Mark') # 当执行程序是碰到switch就切换 def play(name): print('%s play 1' % name) g1.switch() print('%s play 2' % name) # 将函数注册到协程中 g1 = greenlet(eat) g2 = greenlet(play) # 可以在第一次switch时传入参数，以后都不需要 g1.switch('Mark')
单纯的切换 和 普通的对比
（在没有io的情况下或者没有重复开辟内存空间的操作），反而会降低程序的执行速度
普通
import time def f1(): res = 1 for i in range(100000000): res = res + i def f2(): res = 1 for i in range(100000000): res = res * i start = time.time() f1() f2() stop = time.time() print('跑起来的时间是 : %s' % (stop - start))
跑起来的世界是 : 29.81570553779602
单纯的切换
from greenlet import greenlet import time def f1(): res = 1 for i in range(100000000): res = res + i g2.switch() def f2(): res = 1 for i in range(100000000): res = res * i g1.switch() start = time.time() # 将函数注册到协程中 g1 = greenlet(f1) g2 = greenlet(f2) # 启动协程切换 g1.switch() stop = time.time() print('跑起来的时间是 : %s' % (stop - start))
跑起来的时间是 : 92.59229588508606
greenlet只是提供了一种比generator更加便捷的切换方式，当切到一个任务执行时如果遇到io，那就原地阻塞，仍然是没有解决遇到IO自动切换来提升效率的问题。
单线程里的这20个任务的代码通常会既有计算操作又有阻塞操作，我们完全可以在执行任务1时遇到阻塞，就利用阻塞的时间去执行任务2。。。。如此，才能提高效率，这就用到了Gevent模块。
Gevent模块
Gevent 是一个第三方库，可以轻松通过gevent实现并发同步或异步编程，
在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。
Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度。
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的返回值
现象:
下例gevent.sleep(2 )模拟的是gevent可以识别的io阻塞
import gevent def eat(name): print('%s eat 1' % name) # 当我碰到sleep io阻塞的时候我就跳到play中执行，我不会傻等 gevent.sleep(2) print('%s eat 2' % name) def play(name): print('%s play 1' % name) # 如果两个协程都有sleep的话 我就优先执行 io阻塞时间短的 gevent.sleep(1) print('%s play 2' % name) # 在协程中注册一个函数 g1 = gevent.spawn(eat, 'Mark') g2 = gevent.spawn(play, name='Riven') # 等待g1 g2 的结束 gevent.joinall([g1,g2]) # 等待g1 g2 的结束 也可以这样写 # g1.join() # g2.join() print('主')
注意:
而time.sleep(2)或其他的阻塞,gevent是不能直接识别的需要用下面一行代码,打补丁,就可以识别了
from gevent import monkey;monkey.patch_all()
必须放到被打补丁者的前面，如time，socket模块之前
或者我们干脆记忆成：要用gevent，需要将
from gevent import monkey;monkey.patch_all()
放到文件的开头
# 要用gevent，需要将from gevent import monkey;monkey.patch_all()放到文件的开头 # 这样就可以使用time.sleep() from gevent import monkey;monkey.patch_all() import gevent import time def eat(name): print('%s eat 1' % name) # 当我碰到sleep io阻塞的时候我就跳到play中执行，我不会傻等 time.sleep(2) print('%s eat 2' % name) def play(name): print('%s play 1' % name) # 如果两个协程都有sleep的话 我就优先执行 io阻塞时间短的 time.sleep(1) print('%s play 2' % name) # 在协程中注册一个函数 g1 = gevent.spawn(eat, 'Mark') g2 = gevent.spawn(play, name='Riven') # 等待g1 g2 的结束 gevent.joinall([g1, g2]) # 等待g1 g2 的结束 也可以这样写 # g1.join() # g2.join() print('主')
我们可以用
threading.current_thread().getName() : 查看线程的名字.
来查看每个g1和g2，查看的结果为DummyThread-n，即假线程
# 要用gevent，需要将from gevent import monkey;monkey.patch_all()放到文件的开头 # 这样就可以使用time.sleep() from gevent import monkey; monkey.patch_all() import threading import gevent import time def eat(name): # 查看协程 名称 print(threading.current_thread().getName()) print('%s eat 1' % name) # 当我碰到sleep io阻塞的时候我就跳到play中执行，我不会傻等 time.sleep(2) print('%s eat 2' % name) def play(name): # 查看协程 名称 print(threading.current_thread().getName()) print('%s play 1' % name) # 如果两个协程都有sleep的话 我就优先执行 io阻塞时间短的 time.sleep(1) print('%s play 2' % name) # 在协程中注册一个函数 g1 = gevent.spawn(eat, 'Mark') g2 = gevent.spawn(play, name='Riven') # 等待g1 g2 的结束 gevent.joinall([g1, g2]) # 等待g1 g2 的结束 也可以这样写 # g1.join() # g2.join() print('主')
Gevent之同步与异步
from gevent import spawn,joinall,monkey;monkey.patch_all() import time def task(pid): """ Some non-deterministic task """ time.sleep(0.5) print('Task %s done' % pid) def synchronous(): # 同步 for i in range(10): task(i) def asynchronous(): # 异步 g_l=[spawn(task,i) for i in range(10)] joinall(g_l) print('DONE') if __name__ == '__main__': print('Synchronous:') synchronous() print('Asynchronous:') asynchronous() # 上面程序的重要部分是将task函数封装到Greenlet内部线程的gevent.spawn。 # 初始化的greenlet列表存放在数组threads中，此数组被传给gevent.joinall 函数， # 后者阻塞当前流程，并执行所有给定的greenlet任务。执行流程只会在 所有greenlet执行完后才会继续向下走。
Gevent之应用举例一
通过gevent实现单线程下的socket并发
注意 ：from gevent import monkey;monkey.patch_all()
一定要放到导入socket模块之前，否则gevent无法识别socket的阻塞
from gevent import monkey;monkey.patch_all() from socket import * import gevent #如果不想用money.patch_all()打补丁,可以用gevent自带的socket # from gevent import socket # s=socket.socket() def server(server_ip,port): s=socket(AF_INET,SOCK_STREAM) s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) s.bind((server_ip,port)) s.listen(5) while True: conn,addr=s.accept() gevent.spawn(talk,conn,addr) def talk(conn,addr): try: while True: res=conn.recv(1024) print('client %s:%s msg: %s' %(addr[0],addr[1],res)) conn.send(res.upper()) except Exception as e: print(e) finally: conn.close() if __name__ == '__main__': server('127.0.0.1',8080)
from socket import * client=socket(AF_INET,SOCK_STREAM) client.connect(('127.0.0.1',8080)) while True: msg=input('>>: ').strip() if not msg:continue client.send(msg.encode('utf-8')) msg=client.recv(1024) print(msg.decode('utf-8'))
from threading import Thread from socket import * import threading def client(server_ip,port): c=socket(AF_INET,SOCK_STREAM) #套接字对象一定要加到函数内，即局部名称空间内，放在函数外则被所有线程共享，则大家公用一个套接字对象，那么客户端端口永远一样了 c.connect((server_ip,port)) count=0 while True: c.send(('%s say hello %s' %(threading.current_thread().getName(),count)).encode('utf-8')) msg=c.recv(1024) print(msg.decode('utf-8')) count+=1 if __name__ == '__main__': for i in range(500): t=Thread(target=client,args=('127.0.0.1',8080)) t.start()
