多執行緒例項、鎖
阿新 • • 發佈：2019-02-11
- 多執行緒例項
程序是程式在計算機上的一次執行活動。當你執行一個程式，你就啟動了一個程序。顯然，程式是死的(靜態的)，程序是活的(動態的)。程序可以分為系統程序和使用者程序。凡是用於完成作業系統的各種功能的程序就是系統程序，它們就是處於執行狀態下的作業系統本身；使用者程序就不必我多講了吧，所有由你啟動的程序都是使用者程序。程序是作業系統進行資源分配的單位。
它的思想簡單介紹如下：在作業系統的管理下，所有正在執行的程序輪流使用CPU，每個程序允許佔用CPU的時間非常短(比如10毫秒)，這樣使用者根本感覺不出來CPU是在輪流為多個程序服務，就好象所有的程序都在不間斷地執行一樣。但實際上在任何一個時間內有且僅有一個程序佔有CPU。
多程序和多執行緒的區別：
多執行緒使用的是cpu的一個核，適合io密集型
多程序使用的是cpu的多個核，適合運算密集型
元件：
Python提供了非常好用的多程序包，multiprocessing，我們在使用的時候，只需要匯入該模組就可以了。
Multiprocessing支援子程序，通訊，共享資料，執行不同形式的同步，提供了Process，Pipe, Lock等元件
Process
1. 建立一個Process物件
p = multiprocessing.Process(target=worker_1, args=(2, ))
target = 函式名字
args = 函式需要的引數，以tuple的形式傳入
注意： 單個元素的tuple的表現形式
multprocessing用到的兩個方法
cpu_count()統計cpu總數
active_children()獲得所有子程序
Process的常用方法
is_alive() 判斷程序是否存活
run()啟動程序
start() 啟動程序，會自動呼叫run方法，這個常用
join(timeout)等待程序結束或者直到超時
Process的常用屬性
name 程序名字
pid程序的pidimport multiprocessing import time def work(interval, method): print("start work_" + method) time.sleep(interval) print("end work_" + method) if __name__ == "__main__": p1 = multiprocessing.Process(target=work, args=(1, "1")) p2 = multiprocessing.Process(target=work, args=(2, "2")) p3 = multiprocessing.Process(target=work, args=(3, "3")) p1.start() p2.start() p3.start() print("The number of CPU is:") + str(multiprocessing.cpu_count()) for p in multiprocessing.active_children(): print("The name of active child is: " + p.name + ", pid is: " + str(p.pid) + "is alive: " + str(p.is_alive())) print("MAIN IS END!") - 多執行緒鎖
資源加鎖其實並不是給資源加鎖, 而是用鎖去鎖定資源，你可以定義多個鎖, 像下面的程式碼, 當你需要獨佔某一資源時，任何一個鎖都可以鎖這個資源。
就好比你用不同的鎖都可以把相同的一個門鎖住是一個道理。
執行緒不安全:import threading import time counter = 0 counter_lock = threading.Lock() #只是定義一個鎖,並不是給資源加鎖,你可以定義多個鎖,像下兩行程式碼,當你需要佔用這個資源時，任何一個鎖都可以鎖這個資源 counter_lock2 = threading.Lock() counter_lock3 = threading.Lock() #可以使用上邊三個鎖的任何一個來鎖定資源 class MyThread(threading.Thread):#使用類定義thread，繼承threading.Thread def __init__(self,name): threading.Thread.__init__(self) self.name = "Thread-" + str(name) def run(self): #run函式必須實現 global counter,counter_lock #多執行緒是共享資源的，使用全域性變數 time.sleep(1); if counter_lock.acquire(): #當需要獨佔counter資源時，必須先鎖定，這個鎖可以是任意的一個鎖，可以使用上邊定義的3個鎖中的任意一個 counter += 1 print "I am %s, set counter:%s" % (self.name,counter) counter_lock.release() #使用完counter資源必須要將這個鎖開啟，讓其他執行緒使用 if __name__ == "__main__": for i in xrange(1,101): my_thread = MyThread(i) my_thread.start()
最普通的一個多執行緒小例子。我一筆帶過地講一講，我建立了一個繼承Thread類的子類MyThread，作為我們的執行緒啟動類。按照規定，重寫Thread的run方法，我們的執行緒啟動起來後會自動呼叫該方法。於是我首先建立了10個執行緒，並將其加入列表中。再使用一個for迴圈，開啟每個執行緒。在使用一個for迴圈，呼叫join方法等待所有執行緒結束才退出主執行緒。
這段程式碼看似簡單，但實際上隱藏著一個很大的問題，只是在這裡沒有體現出來。你真的以為我建立了10個執行緒，並按順序呼叫了這10個執行緒，每個執行緒為n增加了1.實際上，有可能是A執行緒執行了n++，再C執行緒執行了n++，再B執行緒執行n++。
這裡涉及到一個“鎖”的問題，如果有多個執行緒同時操作一個物件，如果沒有很好地保護該物件，會造成程式結果的不可預期（比如我們在每個執行緒的run方法中加入一個time.sleep(1)，並同時輸出執行緒名稱，則我們會發現，輸出會亂七八糟。因為可能我們的一個print語句只打印出一半的字元，這個執行緒就被暫停，執行另一個去了，所以我們看到的結果很亂），這種現象叫做“執行緒不安全”
執行緒鎖：
於是，Threading模組為我們提供了一個類，Threading.Lock，鎖。我們建立一個該類物件，線上程函式執行前，“搶佔”該鎖，執行完成後，“釋放”該鎖，則我們確保了每次只有一個執行緒佔有該鎖。這時候對一個公共的物件進行操作，則不會發生執行緒不安全的現象了。
於是，我們把程式碼更改如下：# coding : uft-8 __author__ = 'Phtih0n' import threading, time class MyThread(threading.Thread): def __init__(self): threading.Thread.__init__(self) def run(self): global n, lock time.sleep(1) if lock.acquire(): print n , self.name n += 1 lock.release() if "__main__" == __name__: n = 1 ThreadList = [] lock = threading.Lock() for i in range(1, 200): t = MyThread() ThreadList.append(t) for t in ThreadList: t.start() for t in ThreadList: t.join()