Python並發之協程
《python並發之協程》
一:
單線程下實現並發,即只在一個主線程,並且cpu只有一個的情況下實現並發。(並發的本質:切換+保存狀態)
cpu正在運行一個任務,會在兩種情況下切去執行其他的任務(切換由操作系統強制控制),一種情況是該任務發生了阻塞,第二種情況是該任務計算時間過長。
主線程的三種狀態:
其中第二種情況並不能提升效率,只是為了讓cpu能夠雨露均沾,實現看起來大家都被執行的效果,如果多個程序都是純計算任務,這種切換反而會降低效率。
為此我們基於yield驗證。yield本身就是一種在單線程下可以保存任務運行狀態的方法。
yiled:
1:可以保存狀態,yiled的狀態保存與操作系統的保存線程的狀態很像,但是yiled是代碼級別控制的,更輕量級。
2:send可以把一個函數的結果傳給另外一個函數,以此實現單線程內程序之間的切換。
#串行執行 import time def consumer(res): print(‘任務1:接收數據,處理數據‘) def producer(): print(‘任務2:產生數據‘) res = [] for i in range(10000000): res.append(i) return res start = time.time() #串行執行 res= producer() consumer(res) stop = time.time() print(stop-start) #基於yield並發執行 # import time # def consumer(): # # print(‘任務1:接收數據,處理數據‘) # while True: # x = yield # def producer(): # # print(‘任務2:生產數據‘) # g = consumer() # next(g) # for i in range(10000000):#2.691828966140747 # g.send(i) # start = time.time() #基於yiled保存狀態,實現兩個任務直接來回切換,即並發的效果 #ps:如果每個任務中都加上打印,那麽明顯地看到兩個任務是你一次我一次,即並發執行 # producer() # stop = time.time() # print(stop-start)
而在單線程下,我們不可避免程序中出現io操作,但如果我們能在自己的程序中(即用戶程序級別,而非操作系統級別)控制單線程下多個任務能遇到io就切換,這樣保證了該線程能夠最大限度地處於就緒態,即隨時都可以被cpu執行的狀態,相當於我們在用戶程序級別將io操作最大限度地隱藏起來,該線程好像是一直處於計算過程,io比較少。
協成的本質就是在單線程下,由用戶自己控制一個任務遇到io阻塞了就切換另外一個任務去執行,以此來提升效率。
1:可以控制多個任務之間的切換,切換之前將任務的狀態保存下來(重新運行時,可以基於暫停的位置繼續)
2:作為1的補充:可以檢測io操作,在遇到io操作的情況下發生切換。
二:協稱介紹(Coroutine)
協程:是單線程下的並發,又稱微線程,纖程。
協程是一種用戶態的輕量級線程(是由用戶程序自己控制調度的)
強調:
1:python的線程屬於內核級別的,即由操作系統控制調度(單線程遇到io或執行時間過長就會被迫交出cpu執行權限,切換其他線程運行)
2:單線程內開啟協程,一旦遇到io,就會應用程序級別(而非操作系統)控制切換,以此提升效率(非io操作的切換方式與效率無關)
對比操作系統控制線程的切換,用戶在單線程內控制協程的切換
優點:
1:協程的切換開銷更小,屬於程序級別的切換,操作系統完全感知不到,因而更輕量級。
2:單線程內就可以實現並發的效果,最大限度地利用cpu
缺點:
1:協程的本質就是單線程下,無法利用多核,可以是一個程序開啟多個進程,每個進程內開啟多個線程,每個線程內開啟協程。
2:協程指的是單個線程,因而一旦協程出現阻塞,將會阻塞整個協程。
協程的特點:
1:必須在只有一個單線程裏實現並發。
2:修改共享數據不需要加鎖
3:用戶程序裏自己保存多個控制流的上下文棧。
4:一個協程遇到io操作自動切換到其他協程(如何實現檢測io,yiled,greenlet都無法實現,就用到了geven模塊(select機制))
三:Greenlet
如果我們在單個線程內有20個任務,每個任務的代碼分兩部分:前半部分是純計算,後半部分是純io。
要想實現在多個任務之間切換,yield生成器的方式,需要先得到初始化一次的生成器,然後再調用send。。。非常麻煩,使用greenlet模塊可以非常簡單地實現這20個任務直接的切換
rom greenlet import greenlet import time def eat(name): print(‘%s eat 1‘%name) time.sleep(3) g2.switch(‘悟空‘) 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(‘悟空‘)#可以在第一次swith時傳入參數,以後都不需要
--------------------------結果----------------------------------------
悟空 eat 1
悟空 play 1
悟空 eat 2
悟空 play 2
單純的切換(在沒有io的情況下或者沒有開辟內存空間的操作),反而會降低程序的執行速度
import time def f1(): res = 1 for i in range(100000000): res+=1 def f2(): res = 1 for i in range(100000000): res*=i start = time.time() f1() f2() stop = time.time() print(‘run time is %s‘%(stop-start))#run time is 23.827917337417603 # from greenlet import greenlet # import time # def f1(): # res = 1 # for i in range(100000000): # res+=i # g2.switch() # def f2(): # res = 1 # for i in range(100000000): # res*=i # g1.switch() # start = time.time() # g1 = greenlet(f1) # g2 = greenlet(f2) # g1.switch() # stop = time.time() # print(‘run time is %s‘%(stop-start))#158.59044671058655
greenlet只是提供了一種比generator更加便捷的切換方式,當切到一個任務執行時遇到阻塞io,那就原地阻塞,仍然是沒有解決遇到io自動切換來提升效率的問題。
四: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的返回值
遇到IO阻塞時會自動切換任務:
import gevent 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(3) print(‘%s play 2‘%name) g1 = gevent.spawn(eat,‘悟空‘) g2= gevent.spawn(play,name=‘悟空‘) g1.join() g2.join() #gevent.joinal([g1,g2]) print(‘主‘)
--------------------------------------結果-----------------------------------
悟空 eat 1
悟空 play 1
悟空 eat 2
悟空 play 2
主
上例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()放到文件的開頭
from gevent import monkey;monkey.patch_all() import gevent import time def eat(): print(‘eat food 1‘) time.sleep(2) print(‘eat food 2‘) def play(): print(‘play 1‘) time.sleep(1) print(‘play 2‘) g1 = gevent.spawn(eat) g2 = gevent.spawn(play) gevent.joinall([g1,g2]) print(‘主‘)
------------------------------------結果----------------------------
at food 1
play 1
play 2
eat food 2
主
五:Gevent之同步異步
from gevent import spawn,joinall,monkey;monkey.patch_all() import time def task(pid): #一些不確定的任務 time.sleep(0.5) print(‘Task %s done‘%pid) def synchronuns(): for i in range(10): task(i) def asynchronuns(): g_l = [spawn(task,i) for i in range(10)] joinall(g_l) if __name__ == ‘__main__‘: print(‘Synchronous‘) synchronuns() print(‘A‘) asynchronuns()
#上面程序的重要部分是將task函數封裝到Greenlet內部線程的gevent.spawn。
# 初始化的greenlet列表存放在數組threads中,此數組被傳給gevent.joinall 函數,
# 後者阻塞當前流程,並執行所有給定的greenlet。執行流程只會在 所有greenlet執行完後才
# 會繼續向下走。
------------------------------結果-----------------------------------------------
Synchronous
Task 0 done
Task 1 done
Task 2 done
Task 3 done
Task 4 done
Task 5 done
Task 6 done
Task 7 done
Task 8 done
Task 9 done
A
Task 0 done
Task 9 done
Task 8 done
Task 7 done
Task 6 done
Task 5 done
Task 4 done
Task 3 done
Task 2 done
Task 1 done
六: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()
Python並發之協程