python進階（9）多執行緒

Silent丿丶黑羽發表於2021-02-27
Python執行緒

什麼是執行緒？

執行緒也叫輕量級程式，是作業系統能夠進行運算排程的最小單位，它被包涵在程式之中，是程式中的實際運作單位。執行緒自己不擁有系統資源，只擁有一點兒在執行中必不可少的資源，但它可與同屬一個程式的其他執行緒共享程式所擁有的全部資源。一個執行緒可以建立和撤銷另一個執行緒，同一個程式中的多個執行緒之間可以併發執行
 

為什麼要使用多執行緒？

執行緒在程式中是獨立的、併發的執行流。與分隔的程式相比，程式中執行緒之間的隔離程度要小，它們共享記憶體、檔案控制程式碼 和其他程式應有的狀態。 因為執行緒的劃分尺度小於程式，使得多執行緒程式的併發性高。程式在執行過程之中擁有獨立的記憶體單元，而多個執行緒共享 記憶體，從而極大的提升了程式的執行效率。 執行緒比程式具有更高的效能，這是由於同一個程式中的執行緒都有共性，多個執行緒共享一個程式的虛擬空間。執行緒的共享環境包括程式程式碼段、程式的共有資料等，利用這些共享的資料，執行緒之間很容易實現通訊。 作業系統在建立程式時，必須為程式分配獨立的記憶體空間，並分配大量的相關資源，但建立執行緒則簡單得多。因此，使用多執行緒來實現併發比使用多程式的效能高得要多。
 

多執行緒優點

程式之間不能共享記憶體，但執行緒之間共享記憶體非常容易。作業系統在建立程式時，需要為該程式重新分配系統資源，但建立執行緒的代價則小得多。因此使用多執行緒來實現多工併發執行比使用多程式的效率高 python語言內建了多執行緒功能支援，而不是單純地作為底層作業系統的排程方式，從而簡化了python的多執行緒程式設計。
 

單執行緒執行

import time


def hello():
    print("你好，世界")
    time.sleep(1)


if __name__ == "__main__":
    for i in range(5):
        hello()

執行結果

 

多執行緒執行

import threading
import time

def saySorry():
    print("你好，世界")
    time.sleep(1)

if __name__ == "__main__":
    for i in range(5):
        t = threading.Thread(target=saySorry)  # 建立執行緒物件，此時還未啟動子執行緒
        t.start()  # 啟動執行緒，即讓執行緒開始執行

執行結果

 

執行速度對比

  • 可以明顯看出使用了多執行緒併發的操作，花費時間要短
  • 當呼叫start()時，才會真正的建立執行緒，並且開始執行
     

函式式建立多執行緒

python中多執行緒使用threading模組，threading模組呼叫Thread類

self, group=None, target=None, name=None, args=(), kwargs=None, *, daemon=None
  • group：預設為None;預留給將來擴充套件ThreadGroup時使用類實現。不常用，可以忽略
  • target：代表要執行的函式名，不是函式
  • name：執行緒名，預設情況下的格式是"Thread-N",其中N是一個小的十進位制數
  • args：函式的引數，以元組的形式表示
  • kwargs：關鍵字引數字典

小例子

import threading
from time import sleep
from datetime import datetime


def write(name):
    for i in range(3):
        print("{}正在寫字{}".format(name, i))
        sleep(1)


def draw(name):
    for i in range(3):
        print("{}正在畫畫{}".format(name, i))
        sleep(1)


if __name__ == '__main__':
    print(f'---開始---:{datetime.now()}')
    t1 = threading.Thread(target=write, args=('Jack', ))
    t2 = threading.Thread(target=draw, args=('Tom', ))
    t1.start()
    t2.start()
    print(f'---結束---:{datetime.now()}')

 

檢視執行緒數量threading.enumerate()

import threading
from datetime import datetime
from time import sleep


def write():
    for i in range(3):
        print(f"正在寫字...{i}")
        sleep(1)


def draw():
    for i in range(3):
        print(f"正在畫畫...{i}")
        sleep(1)


if __name__ == '__main__':
    print(f'---開始---:{datetime.now()}')

    t1 = threading.Thread(target=write)
    t2 = threading.Thread(target=draw)

    t1.start()
    t2.start()

    while True:
        length = len(threading.enumerate())
        print(f'當前執行的執行緒數為：{length}')
        if length <= 1:
            break
        sleep(0.5)

結果

最開始列印執行緒數為3個，一個主執行緒+2個子執行緒t1，t2
最後列印執行緒數為1個，是因為子執行緒都結束了，就剩主執行緒了
 

自定義執行緒

繼承threading.Thread來定義執行緒類，其本質是重構Thread類中的run方法
為什麼執行run方法，就會啟動執行緒呢？之前寫函式時，呼叫的是start()方法
因為run方法裡預設執行了start()方法

import threading
from time import sleep


class MyThread(threading.Thread):
    def run(self):
        for i in range(5):
            sleep(1)
            msg = "I'm " + self.name + ' @ ' + str(i)  # name屬性中儲存的是當前執行緒的名字
            print(msg)


if __name__ == '__main__':
    t = MyThread()
    t.start()

結果

 

守護執行緒

'''
    這裡使用setDaemon(True)把所有的子執行緒都變成了主執行緒的守護執行緒，
    因此當主執行緒結束後，子執行緒也會隨之結束，所以當主執行緒結束後，整個程式就退出了。
    所謂’執行緒守護’，就是主執行緒不管該執行緒的執行情況，只要是其他子執行緒結束且主執行緒執行完畢，主執行緒都會關閉。也就是說:主執行緒不等待該守護執行緒的執行完再去關閉。
'''

import threading
import time


def run(n):
    print('task', n)
    time.sleep(1)
    print('3s')
    time.sleep(1)
    print('2s')
    time.sleep(1)
    print('1s')


if __name__ == '__main__':
    t = threading.Thread(target=run, args=('t1',))
    t.setDaemon(True)
    t.start()
    print('end')

結果

task t1
end

通過執行結果可以看出，設定守護執行緒之後，當主執行緒結束時，子執行緒也將立即結束，不再執行

主執行緒等待子執行緒結束(join)

為了讓守護執行緒執行結束之後，主執行緒再結束，我們可以使用join方法，讓主執行緒等待子執行緒執行

import threading
import time


def run(n):
    print('task', n)
    time.sleep(1)
    print('3s')
    time.sleep(1)
    print('2s')
    time.sleep(1)
    print('1s')


if __name__ == '__main__':
    t = threading.Thread(target=run, args=('t1',))
    t.setDaemon(True)  # 把子執行緒設定為守護執行緒，必須在start()之前設定
    t.start()
    t.join()  # 設定主執行緒等待子執行緒結束
    print('end')

結果


task t1
3s
2s
1s
end

 

執行緒共享變數

'''
多執行緒共享全域性變數
執行緒時程式的執行單元，程式時系統分配資源的最小執行單位，所以在同一個程式中的多執行緒是共享資源的
'''
import threading
import time

g_num = 0


def work1(num):
    global g_num
    for i in range(num):
        g_num += 1
    print("----in work1, g_num is %d---"%g_num)


def work2(num):
    global g_num
    for i in range(num):
        g_num += 1
    print("----in work2, g_num is %d---"%g_num)


print("---執行緒建立之前g_num is %d---"%g_num)

t1 = threading.Thread(target=work1, args=(1000000,))
t1.start()

t2 = threading.Thread(target=work2, args=(1000000,))
t2.start()

while len(threading.enumerate()) != 1:
    time.sleep(1)

print("2個執行緒對同一個全域性變數操作之後的最終結果是:%s" % g_num)

結果

---執行緒建立之前g_num is 0---
----in work2, g_num is 1451293---
----in work1, g_num is 1428085---
2個執行緒對同一個全域性變數操作之後的最終結果是:1428085

先來看結果，為什麼不是200000呢？
原因是多執行緒共用同一個變數，可能會出現資源競爭的問題，導致資料不準確，那有什麼解決辦法嗎？下面介紹互斥鎖
 

互斥鎖

由於執行緒之間是進行隨機排程，並且每個執行緒可能只執行n條執行之後，當多個執行緒同時修改同一條資料時可能會出現髒資料，所以出現了執行緒鎖，即同一時刻允許一個執行緒執行操作。執行緒鎖用於鎖定資源，可以定義多個鎖，像下面的程式碼，當需要獨佔 某一個資源時，任何一個鎖都可以鎖定這個資源，就好比你用不同的鎖都可以把這個相同的門鎖住一樣。
 
由於執行緒之間是進行隨機排程的，如果有多個執行緒同時操作一個物件，如果沒有很好地保護該物件，會造成程式結果的不可預期，我們因此也稱為執行緒不安全。
 
為了防止上面情況的發生，就出現了互斥鎖（Lock）

import threading
import time

g_num = 0
# 建立一個互斥鎖
# 預設是未上鎖的狀態
lock = threading.Lock()

def test1(num):
    global g_num
    for i in range(num):
        lock.acquire()  # 上鎖
        g_num += 1
        lock.release()  # 解鎖

    print("---test1---g_num=%d"%g_num)


def test2(num):
    global g_num
    for i in range(num):
        lock.acquire()  # 上鎖
        g_num += 1
        lock.release()  # 解鎖

    print("---test2---g_num=%d"%g_num)

# 建立2個執行緒，讓他們各自對g_num加1000000次
p1 = threading.Thread(target=test1, args=(1000000,))
p1.start()

p2 = threading.Thread(target=test2, args=(1000000,))
p2.start()

# 等待計算完成
while len(threading.enumerate()) != 1:
    time.sleep(1)

print("2個執行緒對同一個全域性變數操作之後的最終結果是:%s" % g_num)

結果

---test2---g_num=1961182
---test1---g_num=2000000
2個執行緒對同一個全域性變數操作之後的最終結果是:2000000

 

上鎖解鎖過程

當一個執行緒呼叫鎖的acquire()方法獲得鎖時，鎖就進入locked狀態。 每次只有一個執行緒可以獲得鎖。如果此時另一個執行緒試圖獲得這個鎖，該執行緒就會變為blocked狀態，稱為“阻塞”，直到擁有鎖的執行緒呼叫鎖的release()方法釋放鎖之後，鎖進入unlocked狀態。 執行緒排程程式從處於同步阻塞狀態的執行緒中選擇一個來獲得鎖，並使得該執行緒進入執行（running）狀態。
 

鎖的好處

  • 確保了某段關鍵程式碼只能由一個執行緒從頭到尾完整地執行
     

鎖的壞處

  • 阻止了多執行緒併發執行，包含鎖的某段程式碼實際上只能以單執行緒模式執行，效率就大大地下降了
  • 由於可以存在多個鎖，不同的執行緒持有不同的鎖，並試圖獲取對方持有的鎖時，可能會造成死鎖
     

GIL全域性直譯器

在非python環境中，單核情況下，同時只能有一個任務執行。多核時可以支援多個執行緒同時執行。但是在python中，無論有多少個核同時只能執行一個執行緒。究其原因，這就是由於GIL的存在導致的。
 
GIL的全程是全域性直譯器，來源是python設計之初的考慮，為了資料安全所做的決定。某個執行緒想要執行，必須先拿到GIL，我們可以把GIL看做是“通行證”，並且在一個python程式之中，GIL只有一個。拿不到通行證的執行緒，就不允許進入CPU執行。GIL只在cpython中才有，因為cpython呼叫的是c語言的原生執行緒，所以他不能直接操作cpu，而只能利用GIL保證同一時間只能有一個執行緒拿到資料。而在pypy和jpython中是沒有GIL的
 
python在使用多執行緒的時候，呼叫的是c語言的原生過程。
 

python針對不同型別的程式碼執行效率也是不同的

  1. CPU密集型程式碼（各種迴圈處理、計算等），在這種情況下，由於計算工作多，ticks技術很快就會達到閥值，然後出發GIL的 釋放與再競爭（多個執行緒來回切換當然是需要消耗資源的），所以python下的多執行緒對CPU密集型程式碼並不友好。
     
  2. IO密集型程式碼（檔案處理、網路爬蟲等設計檔案讀寫操作），多執行緒能夠有效提升效率（單執行緒下有IO操作會進行IO等待， 造成不必要的時間浪費，而開啟多執行緒能線上程A等待時，自動切換到執行緒B，可以不浪費CPU的資源，從而能提升程式的執行 效率）。所以python的多執行緒對IO密集型程式碼比較友好。
     
    主要要看任務的型別，我們把任務分為I/O密集型和計算密集型，而多執行緒在切換中又分為I/O切換和時間切換。如果任務屬於是I/O密集型，若不採用多執行緒，我們在進行I/O操作時，勢必要等待前面一個I/O任務完成後面的I/O任務才能進行，在這個等待的過程中，CPU處於等待狀態，這時如果採用多執行緒的話，剛好可以切換到進行另一個I/O任務。這樣就剛好可以充分利用CPU避免CPU處於閒置狀態，提高效率。但是,如果多執行緒任務都是計算型，CPU會一直在進行工作，直到一定的時間後採取多執行緒時間切換的方式進行切換執行緒，此時CPU一直處於工作狀態， 此種情況下並不能提高效能，相反在切換多執行緒任務時，可能還會造成時間和資源的浪費，導致效能下降。這就是造成上面兩種多執行緒結果不能的解釋。
     

結論:I/O密集型任務，建議採取多執行緒，還可以採用多程式+協程的方式(例如:爬蟲多采用多執行緒處理爬取的資料)；對於計算密集型任務，python此時就不適用了。

相關文章