python 並發編程之多線程

標籤：操作   完成   .exe   from   rate   release   console   rand   對象   

一、線程理論1.什麼是線程

多線程（即多個控制線程）的概念是，在一個進程中存在多個線程，多個線程共用該進程的地址空間，相當於一個車間內有多條流水線，都共用一個車間的資源。

所以，進程只是用來把資源集中到一起（進程只是一個資源單位，或者說資源集合），而線程才是cpu上的執行單位。

2.進程與線程的區別

• 同一進程內的多個線程共用該進程內的地址資源

• 建立線程的開銷要遠小於建立進程的開銷（建立一個進程，就是建立一個車間，涉及到申請空間，而且在該空間內建至少一條流水線，但建立線程，就只是在一個車間內造一條流水線，無需申請空間，所以建立開銷小）

3.多線程應用舉例

開啟一個文書處理軟體進程，該進程肯定需要辦不止一件事情，比如監聽鍵盤輸入，處理文字，定時自動將文字儲存到硬碟，這三個任務操作的都是同一塊資料，因而不能用多進程。只能在一個進程裡並發地開啟三個線程,如果是單線程，那就只能是，鍵盤輸入時，不能處理文字和自動儲存，自動儲存時又不能輸入和處理文字。

二、開啟線程的兩種方式

方式一：

import time, randomfrom threading import Threaddef task(name):    print('%s is running' %name)    time.sleep(random.randrange(1, 3))    print('%s running end' %name)if __name__ == '__main__':    t1 = Thread(target=task, args=('gudon', ))    t1.start()    print('主線程。。。')        ---------------------------列印結果-----------------------------gudon is running主線程。。。gudon running end

方式二：

import time, randomfrom threading import Threadclass MyThread(Thread):    def __init__(self, name):        super().__init__()        self.name = name    def run(self):        print('%s is running' %self.name)        time.sleep(random.randrange(1,3))        print('%s running end' %self.name)if __name__ == "__main__":    t1 = MyThread('Astro')    t1.start()    print('主線程......')    ---------------------------列印結果-----------------------------Astro is running主線程......Astro running end

multprocess 、threading 兩個模組在使用方式上相似性很大

二、進程與線程的區別1.開線程的開銷遠小於開進程的開銷

進程：

import time, randomfrom threading import Threadfrom multiprocessing import Processdef task(name):    print('%s is running' %name)    time.sleep(random.randrange(1, 3))    print('%s running end' %name)if __name__ == '__main__':    p = Process(target=task, args=('Astro', ))    p.start() # p.start ()將開啟進程的訊號發給作業系統後，作業系統要申請記憶體空間，讓好拷貝父進程地址空間到子進程，開銷遠大於線程    print('主...........')    ---------------------------【進程】列印結果-----------------------------主...........Astro is runningAstro running end

線程：

import time, randomfrom threading import Threadfrom multiprocessing import Processdef task(name):    print('%s is running' %name)    time.sleep(random.randrange(1, 3))    print('%s running end' %name)if __name__ == '__main__':    t1 = Thread(target=task, args=('Astro', ))    t1.start() #幾乎是t.start ()的同時就將線程開啟了，線程的建立開銷要小魚進程建立的開銷    print('主...........')    ---------------------------【線程】列印結果-----------------------------Astro is running主...........Astro running end

2.同一進程內的多個線程共用該進程的地址空間

from threading import Threadfrom multiprocessing import Processn = 100def task():    global n    n = 0if __name__ == "__main__":    p1 = Process(target=task)    p1.start()    p1.join()    print('主 %s' %n)      ---------------------------列印結果-----------------------------主 100

子進程 p1 建立的時候，會把主進程中的資料複製一份，進程之間資料不會互相影響，所以子進程p1 中 n=0 後，只是子進程中的 n 改了，主進程的 n 不會受影響 ,即 進程之間地址空間是隔離的

from threading import Threadfrom multiprocessing import Processn = 100def task():    global n    n = 0if __name__ == "__main__":    t1 = Thread(target=task)    t1.start()    t1.join()    print('主 %s' %n)---------------------------列印結果-----------------------------主 0

同一進程內的線程之間共用進程內的資料，所以為 0

3. pid

pid 就是 process id ,進程的id號。

開多個進程,每個進程都有不同的pid：

from multiprocessing import Process, current_processfrom threading import Threadimport osdef task():   # print('子進程...', current_process().pid)  # 也可以使用 os.getpid()或 current_process().pid 來查看當前進程的pid，os.getppid() 可以查看當前進程的父進程的pid    print('子進程PID:%s  父進程的PID:%s' % (os.getpid(), os.getppid()))if __name__ == '__main__':    p1 = Process(target=task)    p1.start()    print('主線程', current_process().pid)        ---------------------------列印結果-----------------------------主線程 808子進程PID:7668  父進程的PID:808

在主進程下開啟多個線程,每個線程都跟主進程的pid一樣

from threading import Threadimport osdef task():    print('子線程pid:',os.getpid())if __name__ == '__main__':    t1 = Thread(target=task, )    t1.start()    print('主線程pid:', os.getpid())---------------------------列印結果-----------------------------子線程pid: 9084主線程pid: 9084

三、Thread對象的其他屬性或方法

Thread執行個體對象的方法  # isAlive(): 返回線程是否活動的。  # getName(): 返回線程名。  # setName(): 設定線程名。threading模組提供的一些方法：  # threading.currentThread(): 返回當前的線程變數。  # threading.enumerate(): 返回一個包含正在啟動並執行線程的list。正在運行指線程啟動後、結束前，不包括啟動前和終止後的線程。  # threading.activeCount(): 返回正在啟動並執行線程數量，與len(threading.enumerate())有相同的結果。

from threading import Thread, currentThread,active_count,enumerateimport timedef task():    print('%s is running '%currentThread().getName())    time.sleep(2)    print('%s is done' %currentThread().getName())if __name__ == "__main__":    t = Thread(target=task, )    # t = Thread(target=task, name='子線程001')  # 也可以在這裡改子線程名字    t.start()    # t.setName('子線程001')    t.join()    currentThread().setName('主線程')    print(active_count())  # 返回正在啟動並執行線程數量    print(enumerate())  # [<_MainThread(主線程, started 6904)>]     預設為：[<_MainThread(MainThread, started 6904)>]        ---------------------------列印結果-----------------------------子線程001 is running 子線程001 is done1[<_MainThread(主線程, started 6432)>]

四、守護線程與互斥鎖1.守護線程

無論是進程還是線程，都遵循：守護xxx會等待主xxx運行完畢後被銷毀

1、對主進程來說，運行完畢指的是主進程代碼運行完畢

主進程在其代碼結束後就已經算運行完畢了（守護進程在此時就被回收）,然後主進程會一直等非守護的子進程都運行完畢後回收子進程的資源(否則會產生殭屍進程)，才會結束，

2、對主線程來說，運行完畢指的是主線程所在的進程內所有非守護線程統統運行完畢，主線程才算運行完畢

主線程在其他非守護線程運行完畢後才算運行完畢（守護線程在此時就被回收）。因為主線程的結束意味著進程的結束，進程整體的資源都將被回收，而進程必須保證非守護線程都運行完畢後才能結束。

from threading import Threadimport timedef sayHi(name):    time.sleep(2)    print('%s say Hello')if __name__ == '__main__':    t = Thread(target=sayHi, args=('Astro', ))    t.setDaemon(True)  # 設定為守護線程， t.daemon = True 也可以    t.start()    print('主線程')    print(t.is_alive())    ----------------------執行結果---------------------------主線程True

t.start() 後，系統會馬上建立出一條子線程，但是由於子線程中 time.sleep(2) ,2秒的時間對電腦來說已經很長了，所以在

print('主線程')print(t.is_alive())

執行後，主線程結束，子線程跟著就結束了，因為我們設定了該子線程為守護線程

在看一個例子：

def foo():    print('foo runing..')    time.sleep(1)    print('foo end')def bar():    print('bar running..')    time.sleep(3)    print('bar end')if __name__ == '__main__':    t1 = Thread(target=foo, )    t2 = Thread(target=bar, )    t1.setDaemon(True)    t1.start()    t2.start()    print('main.......')    ----------------------執行結果---------------------------   foo runing..bar running..main.......foo endbar end

t1 為守護進程，t1.start() 後，馬上執行 foo函數，然後 time.sleep(1)

此時 t2.start() 開啟了線程，執行 bar函數後 time.sleep(3)

3秒的時間內，執行了主線程的 print(‘main......‘) , 然後主線程任務已經完成，但是由於 子線程t2 還未執行完畢，t2 非守護線程，主線程還需要等待 非守護線程t2運行完畢後才能結束，所以在等待 t2結束的時間裡，t1 線程執行完畢，t1隻sleep 1秒，時間上足夠t1 先執行了

然後t2 三秒後執行自己剩下的部分

2.互斥鎖

from threading import Thread, Lockimport timen = 100def task(mutex):    global n    mutex.acquire()  # 加互斥鎖    temp = n    time.sleep(0.1)    n = temp - 1    mutex.release()if __name__ == '__main__':    mutex = Lock()    t_list = []    for i in range(100):        t = Thread(target=task, args=(mutex, ))        t_list.append(t)        t.start()    for t in t_list:        t.join()    print('main....',n) ----------------------執行結果---------------------------main.... 0

如果不加互斥鎖的情況下，得到的結果是 main.... 99

因為，在迴圈中 t.start() 的時候，100個線程會立馬建立出來，然後在函數中，100個線程的 temp都被賦值為了 100，所以 n = temp - 1 只是迴圈的被賦值為 99 而已

另外，互斥鎖只保證裡局部的串列，與join 不一樣

五、GIL 全域解譯器鎖

運行這段代碼

import os, timeprint(os.getpid())  # 5132time.sleep(1000)

然後cmd 查看一下 tasklist |findstr python

結果：

python.exe                    5132 Console                    1      9,568 K

python 並發編程之多線程