python协程重入_python---协程学习笔记

最新推荐文章于 2024-01-07 11:55:52 发布

weixin_39965514

最新推荐文章于 2024-01-07 11:55:52 发布

阅读量140

点赞数

文章标签： python协程重入

本文链接：https://blog.csdn.net/weixin_39965514/article/details/113972163

版权

协程

协程又称为微线程，协程是一种用户态的轻量级线程

协程拥有自己的寄存器和栈。协程调度切换的时候，将寄存器上下文和栈都保存到其他地方，在切换回来的时候，恢复到先前保存的寄存器上下文和栈，因此：协程能保留上一次调用状态，每次过程重入时，就相当于进入上一次调用的状态。

协程的好处：

1.无需线程上下文切换的开销(还是单线程)

2.无需原子操作(一个线程改一个变量，改一个变量的过程就可以称为原子操作)的锁定和同步的开销

3.方便切换控制流，简化编程模型

4.高并发+高扩展+低成本：一个cpu支持上万的协程都没有问题，适合用于高并发处理

缺点：

1.无法利用多核的资源，协程本身是个单线程，它不能同时将单个cpu的多核用上，协程需要和进程配合才能运用到多cpu上(协程是跑在线程上的)

2.进行阻塞操作时会阻塞掉整个程序：如io

使用yield实现协程的例子：

importtimeimportqueuedefconsumer(name):print("---->start eating baozi......")whileTrue:#yield默认可以返回数据，走到yield整个程序返回，yield被唤醒的时候还可以接收数据

#进入死循环碰到yield暂停，被唤醒的时候才执行print

new_baozi = yield

print("[%s] is eating baozi %s" %(name,new_baozi))#time.sleep(2)

defproducer():#__next__()调用消费者的next,consumer直接调用的话，第一次不会执行，会变成一个生成器

#函数如果里面有yield第一次加括号调用，他是一个生成器，还没有真正执行，__next__()才会执行

r = con.__next__()

r= con2.__next__()

n=0while n<5:

n+= 1

#send有两个作用：唤醒生成器的同时，传送一个值，传的这个值就是yield接收到的值new_baozi

con.send(n)

con2.send(n)

#time.sleep(1)print("\033[32;1m[producer]\033[0m is making baozi %s" %n)if __name__ == '__main__':

con= consumer("c1")

con2= consumer("c2")

p= producer()

整个就是通过yield实现的一个简单的协程，在程序运行过程中，直接完成运作，感觉像多并发的效果。

问题：他们好像能够实现多并发的效果，是因为每一个生产者没有任何的sleep，如果在producer中加一个time.sleep(1)，那么运行速度就变慢了。

遇到io操作就切换，io操作很耗时，协程之所以能够处理大并发，就是把io操作去除，之后就变成这个程序只有cpu在切换

如何实现程序自动检测io操作完成：

greenlet

from greenlet importgreenletdeftesst1():print(12)

gr2.switch()print(34)

gr2.switch()deftesst2():print(56)

gr1.switch()print(78)

gr1= greenlet(tesst1)#启动一个协程

gr2 =greenlet(tesst2)

gr1.switch()#手动切换

运行结果：

greenlet现在还是手动切换

gevent

Gevent是一个第三方库，可以轻松通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet，它是以c扩展模块形式接入python的轻量级协程。Greenlet全部运行在主程序操作系统进程的内部，但他们被协作式的调度

importgeventdeffoo():print("Running in foo")

gevent.sleep(2)print("Explicit context switch to foo again")defbar():print("Explicit context to bar")

gevent.sleep(1)print("Implicit context to switch back to bar")

gevent.joinall(

[

gevent.spawn(foo),

gevent.spawn(bar),

]

)

运行结果：

运行整个也就运行了2秒，模拟io操作

下面我们做一个简单的小爬虫：

from urllib.request importurlopenimportgevent,timedeff(url):print("GET: %s"%url)

resp=urlopen(url)

data=resp.read()print("%d bytes received from %s." %(len(data),url))

urls=['https://www.python.org/','https://www.yahoo.com/','https://github.com/']

time_start=time.time()for url inurls:

f(url)print("同步cost",time.time()-time_start)

async_time_start=time.time()

gevent.joinall([

gevent.spawn(f,'https://www.python.org/'),

gevent.spawn(f,'https://www.yahoo.com/'),

gevent.spawn(f,'https://github.com/')

])print("异步cost",time.time()-time_start)

用了同步和异步两种方式来进行网页的爬取，但是结果却是同步的比异步的用的时间还要短，我们之前用了gevent.sleep(1)来模拟io操作，顺便就完成了执行任务。原因是：gevent调用urllib默认是堵塞的，gevent检测不到urllib的io操作，所以不会进行切换，所以还是串行运行。

那怎么才能够让gevent知道urllib是io操作呢，要用到一个模块monkey

from urllib.request importurlopenimportgevent,timefrom gevent importmonkey

monkey.patch_all()#把当前程序的所有io操作单独的坐上标记

deff(url):print("GET: %s"%url)

resp=urlopen(url)

data=resp.read()print("%d bytes received from %s." %(len(data),url))

urls=['https://www.python.org/','https://www.yahoo.com/','https://github.com/']

time_start=time.time()for url inurls:

f(url)print("同步cost",time.time()-time_start)

async_time_start=time.time()

gevent.joinall([

gevent.spawn(f,'https://www.python.org/'),

gevent.spawn(f,'https://www.yahoo.com/'),

gevent.spawn(f,'https://github.com/')

])print("异步cost",time.time()-async_time_start)

这样就异步爬取的速度瞬间快了很多

下面我们在利用gevent写一个socket服务器端和客户端：

服务器端：

1 importsys,socket,time,gevent2

3 from gevent importsocket,monkey4 monkey.patch_all()5

6 defserver(port):7 s =socket.socket()8 s.bind(('0.0.0.0',port))9 s.listen(500)10 whileTrue:11 cli,addr =s.accept()12 gevent.spawn(handle_request,cli)13 defhandle_request(conn):14 try:15 whileTrue:16 data = conn.recv(1024)17 print("recv:",data)18 conn.send(data)19 if notdata:20 conn.shutdown(socket.SHUT_WR)21 exceptException as e:22 print(e)23 finally:24 conn.close()25

26 if __name__ == '__main__':27 server(8001)

和socketserver差不多，处理数据都是在handle_request函数中，然后在server中建立一个gevent

客户端：

1 importsocket2 HOST = 'localhost'

3 PORT = 8001

4 s =socket.socket(socket.AF_INET,socket.SOCK_STREAM)5 s.connect((HOST,PORT))6 whileTrue:7 msg = bytes(input(">>>:"),encoding="utf-8")8 s.sendall(msg)9 data = s.recv(1024)10 #repr格式化输出

11 print("Recv:",repr(data))12 s.close()

运行结果：