python 線程(隊列,線程池),協程(理論greenlet,gevent模組,)

標籤：做了   name   修改   bbb   程式   pid   提高效率   系統進程   highlight   

線程的隊列:

queue隊列,使用import queue,用法與進程Queue一樣

queue is especially useful in threaded programming when information must be exchanged safely between multiple threads.

class queue.Queue(maxsize=0) #先進先出

import queueq=queue.Queue()q.put(‘first‘)q.put(‘second‘)q.put(‘third‘)print(q.get())print(q.get())print(q.get())‘‘‘結果(先進先出):firstsecondthird‘‘‘先進先出

class queue.LifoQueue(maxsize=0) #last in fisrt out

import queueq=queue.LifoQueue()q.put(‘first‘)q.put(‘second‘)q.put(‘third‘)print(q.get())print(q.get())print(q.get())‘‘‘結果(後進先出):thirdsecondfirst‘‘‘後進先出

class queue.PriorityQueue(maxsize=0) #儲存資料時可設定優先權的隊列　　

import queueq=queue.PriorityQueue()#put進入一個元組,元組的第一個元素是優先順序(通常是數字,也可以是非數字之間的比較),數字越小優先順序越高q.put((20,‘a‘))q.put((10,‘b‘))q.put((30,‘c‘))print(q.get())print(q.get())print(q.get())‘‘‘結果(數字越小優先順序越高,優先順序高的優先出隊):(10, ‘b‘)(20, ‘a‘)(30, ‘c‘)‘‘‘優先順序隊列

線程池的問題:

#1 介紹concurrent.futures模組提供了高度封裝的非同步呼叫介面ThreadPoolExecutor：線程池，提供非同步呼叫ProcessPoolExecutor: 進程池，提供非同步呼叫Both implement the same interface, which is defined by the abstract Executor class.#2 基本方法#submit(fn, *args, **kwargs)非同步提交任務#map(func, *iterables, timeout=None, chunksize=1) 取代for迴圈submit的操作#shutdown(wait=True) 相當於進程池的pool.close()+pool.join()操作wait=True，等待池內所有任務執行完畢回收完資源後才繼續wait=False，立即返回，並不會等待池內的任務執行完畢但不管wait參數為何值，整個程式都會等到所有任務執行完畢submit和map必須在shutdown之前#result(timeout=None)取得結果#add_done_callback(fn)回呼函數

mport timefrom threading import currentThread,get_identfrom concurrent.futures import ThreadPoolExecutor  # 協助你啟動線程池的類from concurrent.futures import ProcessPoolExecutor  # 協助你啟動線程池的類def func(i):    time.sleep(1)    print(‘in %s %s‘%(i,currentThread()))    return i**2def back(fn):    print(fn.result(),currentThread())# map啟動多線程任務# t = ThreadPoolExecutor(5)# t.map(func,range(20))# for i in range(20):#     t.submit(func,i)# submit非同步提交任務# t = ThreadPoolExecutor(5)# for i in range(20):#     t.submit(fn=func,)# t.shutdown()# print(‘main : ‘,currentThread())# 起多少個線程池    # 5*CPU的個數# 擷取任務結果# t = ThreadPoolExecutor(20)# ret_l = []# for i in range(20):#     ret = t.submit(func,i)#     ret_l.append(ret)# t.shutdown()# for ret in ret_l:#     print(ret.result())# print(‘main : ‘,currentThread())# 回呼函數t = ThreadPoolExecutor(20)for i in range(100):    t.submit(func,i).add_done_callback(back)

# 回呼函數(進程版)import osimport timefrom concurrent.futures import ProcessPoolExecutor  # 協助你啟動線程池的類def func(i):    time.sleep(1)    print(‘in %s %s‘%(i,os.getpid()))    return i**2def back(fn):    print(fn.result(),os.getpid())if __name__ == ‘__main__‘:    print(‘main : ‘,os.getpid())    t = ProcessPoolExecutor(20)    for i in range(100):        t.submit(func,i).add_done_callback(back)

multiprocessing模組內建進程池的
threading 模組是沒有線程池的

concurrent.futures 進程池 和 線程池

建立線程池/進程池 ProcessPoolExecutor ThreadPoolExecutor

ret = t.submit(func,arg1,arg2...) 非同步提交任務

ret.result() 擷取結果,如果要想實現非同步效果,應該使用列表

map(func,iterable)　

shutdown close+join 同步控制的

add_done_callback 回呼函數,在回呼函數內接收的參數是一個對象,需要通過result來擷取傳回值

　　回呼函數仍然在主進程中執行

 

 

 

 

協程:

之前我們學習了線程、進程的概念，瞭解了在作業系統中進程是資源分派的最小單位,線程是CPU調度的最小單位。按道理來說我們已經算是把cpu的利用率提高很多了。但是我們知道無論是建立多進程還是建立多線程來解決問題，都要消耗一定的時間來建立進程、建立線程、以及管理他們之間的切換。

　　隨著我們對於效率的追求不斷提高，基於單線程來實現並發又成為一個新的課題，即只用一個主線程（很明顯可利用的cpu只有一個）情況下實現並發。這樣就可以節省建立線進程所消耗的時間。

　　為此我們需要先回顧下並發的本質：切換+儲存狀態

 　　cpu正在運行一個任務，會在兩種情況下切走去執行其他的任務（切換由作業系統強制控制），一種情況是該任務發生了阻塞，另外一種情況是該任務計算的時間過長

　  　

　　ps：在介紹進程理論時，提及進程的三種執行狀態，而線程才是執行單位，所以也可以將理解為線程的三種狀態 

　　 一：其中第二種情況並不能提升效率，只是為了讓cpu能夠雨露均沾，實現看起來所有任務都被“同時”執行的效果，如果多個任務都是純計算的，這種切換反而會降低效率。

　　為此我們可以基於yield來驗證。yield本身就是一種在單線程下可以儲存任務運行狀態的方法，我們來簡單複習一下：

#1 yiled可以儲存狀態，yield的狀態儲存與作業系統的儲存線程狀態很像，但是yield是代碼層級控制的，更輕量級#2 send可以把一個函數的結果傳給另外一個函數，以此實現單線程內程式之間的切換

進程:資源分派的最小單位,班級

線程:cpu調度最小單位,人

什麼是協程:能在一條線程的基礎上,在多個任務之間互相切換

節省了線程開啟的消耗

是從python代碼層級調度的

　　　　正常的線程是cpu調度的最小單位

　　　　協程的調度並不是由作業系統來完成的

所學的協程:

# 你學過協程# 在兩個任務之間互相切換# def func():#     print(1)#     x = yield ‘aaa‘#     print(x)#     yield ‘bbb‘## g = func()# print(next(g))# print(g.send(‘****‘))# 在多個函數之間互相切換的功能 - 協程# def consumer():#     while True:#         x = yield#         print(x)# def producer():#     g = consumer()#     next(g)   # 預激#     for i in range(10):#         g.send(i)# producer()# yeild 只有程式之間的切換,沒有重利用任何IO操作的時間

協程介紹

協程：是單線程下的並發，又稱微線程，纖程。英文名Coroutine。一句話說明什麼是線程：協程是一種使用者態的輕量級線程，即協程是由使用者程式自己控制調度的。、

需要強調的是：

#1. python的線程屬於核心層級的，即由作業系統控制調度（如單線程遇到io或執行時間過長就會被迫交出cpu執行許可權，切換其他線程運行）#2. 單線程內開啟協程，一旦遇到io，就會從應用程式層級（而非作業系統）控制切換，以此來提升效率（！！！非io操作的切換與效率無關）

對比作業系統控制線程的切換，使用者在單線程內控制協程的切換

優點如下：

#1. 協程的切換開銷更小，屬於程式層級的切換，作業系統完全感知不到，因而更加輕量級#2. 單線程內就可以實現並發的效果，最大限度地利用cpu

缺點如下：

#1. 協程的本質是單線程下，無法利用多核，可以是一個程式開啟多個進程，每個進程內開啟多個線程，每個線程內開啟協程#2. 協程指的是單個線程，因而一旦協程出現阻塞，將會阻塞整個線程

總結協程特點：

1. 必須在只有一個單線程裡實現並發
2. 修改共用資料不需加鎖
3. 使用者程式裡自己儲存多個控制流程的上下文棧
4. 附加：一個協程遇到IO操作自動切換到其它協程（如何?檢測IO，yield、greenlet都無法實現，就用到了gevent模組（select機制））

使用pip3 install greenlet來安裝greenlet模組

greenlet:　

def eat():#     print(‘吃‘)#     time.sleep(1)#     g2.switch()  # 切換#     print(‘吃完了‘)#     time.sleep(1)#     g2.switch()## def play():#     print(‘玩兒‘)#     time.sleep(1)#     g1.switch()#     print(‘玩兒美了‘)#     time.sleep(1)## g1 = greenlet(eat)# g2 = greenlet(play)# g1.switch()   # 切換# 遇到IO就切換# gevent    pip3 install gevent# greenlet是gevent的底層# gevent是基於greenlet實現的# python代碼在控製程序的切換

greenlet只是提供了一種比generator更加便捷的切換方式，當切到一個任務執行時如果遇到io，那就原地阻塞，仍然是沒有解決遇到IO自動切換來提升效率的問題。

單線程裡的這20個任務的代碼通常會既有計算操作又有阻塞操作，我們完全可以在執行任務1時遇到阻塞，就利用阻塞的時間去執行任務2。。。。如此，才能提高效率，這就用到了Gevent模組。

比較:

#順序執行import timedef f1():    res=1    for i in range(100000000):        res+=idef f2():    res=1    for i in range(100000000):        res*=istart=time.time()f1()f2()stop=time.time()print(‘run time is %s‘ %(stop-start)) #10.985628366470337#切換from greenlet import greenletimport timedef 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)) # 52.763017892837524效率對比

Gevent模組

安裝：pip3 install 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的傳回值用法介紹

import geventdef 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(1)    print(‘%s play 2‘ %name)g1=gevent.spawn(eat,‘egon‘)g2=gevent.spawn(play,name=‘egon‘)g1.join()g2.join()#或者gevent.joinall([g1,g2])print(‘主‘)例：遇到io主動切換

例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()放到檔案的開頭

# 使用協程減少IO操作帶來的時間消耗from gevent import monkey;monkey.patch_all()import geventimport timedef eat():    print(‘吃‘)    time.sleep(2)    print(‘吃完了‘)def play():    print(‘玩兒‘)    time.sleep(1)    print(‘玩兒美了‘)g1 = gevent.spawn(eat)g2 = gevent.spawn(play)gevent.joinall([g1,g2])# g1.join()# g2.join()# 沒執行# 為什麼沒執行???是需要開啟麼?# 沒有開啟但是切換了    # gevent幫你做了切換,做切換是有條件的,遇到IO才切換    # gevent不認識除了gevent這個模組內以外的IO操作    # 使用join可以一直阻塞直到協程任務完成# 協助gevent來認識其他模組中的阻塞    # from gevent import monkey;monkey.patch_all()寫在其他模組匯入之前

import threadingimport geventimport timedef eat():    print(threading.current_thread().getName())    print(‘eat food 1‘)    time.sleep(2)    print(‘eat food 2‘)def play():    print(threading.current_thread().getName())    print(‘play 1‘)    time.sleep(1)    print(‘play 2‘)g1=gevent.spawn(eat)g2=gevent.spawn(play)gevent.joinall([g1,g2])print(‘主‘)查看threading.current_thread().getName()我們可以用threading.current_thread().getName()來查看每個g1和g2，查看的結果為DummyThread-n，即假線程

Gevent之同步與非同步　　

from gevent import spawn,joinall,monkey;monkey.patch_all()import timedef 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執行完後才會繼續向下走。

　協程來實現socket()

from gevent import monkey;monkey.patch_all()import socketimport geventdef talk(conn):    while True:        conn.send(b‘hello‘)        print(conn.recv(1024))sk = socket.socket()sk.bind((‘127.0.0.1‘,9090))sk.listen()while True:    conn,addr = sk.accept()    gevent.spawn(talk,conn)


server

import  socketfrom threading import Threaddef client():    sk = socket.socket()    sk.connect((‘127.0.0.1‘,9090))    while True:        print(sk.recv(1024))        sk.send(b‘bye‘)for i in range(500):    Thread(target=client).start()

client

　　

# 4C 並發50000 qps
# 5個進程
# 20個線程
# 500個協程

 

協程: 能夠在單核情況下 極大地提高cpu的利用率

　　不存在資料不安全的問題

　　也不存線上程切換\創造的時間開銷

　　切換時使用者層級的,程式不會因為協程中某一個任務進入阻塞狀態而使整個線程阻塞

線程的切換

　　時間片到了 降低cpu的效率

　　io會切 　　提高了cpu效率　　

　

　　

　　

　　

　　

　　

　　

　　

　　

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

　　

python 線程(隊列,線程池),協程(理論greenlet,gevent模組,)