协程

一、协程的本质：

单线程实现并发,在应用程序里控制多个任务的切换+保存状态

二、协程的目的：

想要在单线程下实现并发
并发指的是多个任务看起来是同时运行的
并发=切换+保存状态

三、补充：

yiled可以保存状态，yield的状态保存与操作系统的保存线程状态很像，但是yield是代码级别控制的，更轻量级
send可以把一个函数的结果传给另外一个函数，以此实现单线程内程序之间的切换
如何实现检测IO，yield、greenlet都无法实现，就用到了gevent模块（select机制）

四、优点

应用程序级别速度要远远高于操作系统的切换

五、缺点

多个任务一旦有一个阻塞没有切，整个线程都阻塞在原地，该线程内的其他的任务都不能执行了
一旦引入协程，就需要检测单线程下所有的IO行为,实现遇到IO就切换,少一个都不行，因为如果一个任务阻塞了，整个线程就阻塞了，其他的任务即便是可以计算，但是也无法运行了

注意：单纯地切换反而会降低运行效率

#并发执行

import time

def producer():

g=consumer()

next(g)

for i in range(100):

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)

greenlet

greenlet只是提供了一种比generator更加便捷的切换方式，当切到一个任务执行时如果遇到io，那就原地阻塞，仍然是没有解决遇到IO自动切换来提升效率的问题。

注意：单纯的切换（在没有io的情况下或者没有重复开辟内存空间的操作），反而会降低程序的执行速度

#pip3 install greenlet

from greenlet import greenlet

import time

def eat(name):

print('%s eat 1' %name)

time.sleep(2)

g2.switch('tom')

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('tom')

"""

tom eat 1

tom play 1

tom eat 2

tom play 2

"""

gevent

遇到IO阻塞时会自动切换任务

一、用法：

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阻塞,
而time.sleep(2)或其他的阻塞,gevent是不能直接识别的需要用下面一行代码,打补丁,就可以识别了
from gevent import monkey;monkey.patch_all()必须放到被打补丁者的前面，如time，socket模块之前或者我们干脆记忆成：要用gevent，需要将from gevent import monkey;monkey.patch_all()放到文件的开头

#pip3 install gevent

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(2)

print('%s play 2' % name)

start_time=time.time()

g1=gevent.spawn(eat,'tom')

g2=gevent.spawn(play,'rose')

g1.join()

g2.join()

stop_time=time.time()

print(stop_time-start_time)

"""

tom eat 1

rose play 1

rose play 2

tom eat 2

3.003171920776367

"""

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(2)

print('%s play 2' % name)

g1=gevent.spawn(eat,'tom')

g2=gevent.spawn(play,'rose')

# g1.join()

# g2.join()

gevent.joinall([g1,g2])

三、通过gevent实现单线程下的socket并发

from gevent import monkey;monkey.patch_all()一定要放到导入socket模块之前，否则gevent无法识别socket的阻塞

"""

服务端

#基于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)

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()

if __name__ == '__main__':

for i in range(500):

t=Thread(target=client)

t.start()

eat

python 协程

协程

一、协程的本质：

二、协程的目的：

三、补充：

四、优点

五、缺点

注意：单纯地切换反而会降低运行效率

greenlet

注意：单纯的切换（在没有io的情况下或者没有重复开辟内存空间的操作），反而会降低程序的执行速度

gevent

一、用法：

二、补充：

三、通过gevent实现单线程下的socket并发