多工 執行緒基礎與總結

一、對執行緒的理解

1.乙個程式執行起來至少有乙個程序，乙個程序至少有乙個執行緒

2.處理器cpu分配給執行緒，即cpu真正執行的是執行緒中的**

3.分配cpu給執行緒時，是通過時間片輪訓方式進行的

4.程序是作業系統分配程式執行資源的單位，而執行緒是程序的乙個實體，是cpu排程和分配的單位。

二、python實現多執行緒的兩種方式

1、建立函式並且傳入thread 物件中

示例如下：

#

引入threading執行緒模組
import
threading
import
time
defdownload_music():
""""""
for i in range(5):
time.sleep(1)  #
休眠1秒
print("
" %i)
defplay_music():
""""""
for i in range(5):
time.sleep(1)  #
休眠1秒
print("
" %i)
defmain():
#建立執行緒物件t1
#target: 指向新開啟的執行緒要執行的**
t1 = threading.thread(target=download_music)
t2 = threading.thread(target=play_music)
t1.start()  
#啟動執行緒，既然執行緒開始執行
t2.start()
if__name__ == '
__main__':
main()

2.繼承thread類，建立乙個新的class，將要執行的** 寫到run函式裡面

#

自定義類，繼承threading.thread
class
mythread(threading.thread):
defrun(self):
for i in range(5):
time.sleep(1)
#name屬性中儲存的是當前執行緒的名字
msg = "
i'm 
" + self.name + '
@ ' +str(i)
print
(msg)
if__name__ == '
__main__':
#通過mythread建立執行緒物件
t1 =mythread()
#開始執行執行緒
t1.start()

三、執行緒何時開啟，何時結束

1.子執行緒何時開啟，何時執行

當呼叫thread.start()時 開啟執行緒，再執行執行緒的**

2.子執行緒何時結束

子執行緒把target指向的函式中的語句執行完畢後，或者執行緒中的run函式**執行完畢後，立即結束當前子執行緒

3.檢視當前執行緒數量

通過threading.enumerate()可列舉當前執行的所有執行緒

4.主線程何時結束

所有子執行緒執行完畢後，主線程才結束

四、多執行緒（共享全域性變數的問題）

1.在乙個程序內的所有執行緒共享全域性變數，很方便在多個執行緒間共享資料

2.缺點就是，多執行緒對全域性變數隨意遂改可能造成全域性變數的混亂（即執行緒非安全）

3.如果多個執行緒同時對同乙個全域性變數操作，會出現資源競爭問題，從而資料結果會不正確，即會遇到執行緒安全問題

五、互斥鎖

1.當多個執行緒幾乎同時修改某乙個共享資料的時候，需要進行同步控制

2.執行緒同步能夠保證多個執行緒安全訪問競爭資源，最簡單的同步機制是引入互斥鎖。

3.互斥鎖為資源引入乙個狀態：鎖定/非鎖定

4.某個執行緒要更改共享資料時，先將其鎖定，此時資源的狀態為「鎖定」，其他執行緒不能更改；直到該執行緒釋放資源，將資源的狀態變成「非鎖定」，其他的執行緒才能再次鎖定該資源。互斥鎖保證了每次只有乙個執行緒進行寫入操作，從而保證了多執行緒情況下資料的正確性。

5.hreading模組中定義了lock類，可以方便的處理鎖定：

#

建立鎖mutex =threading.lock()#鎖定
mutex.acquire()#釋放
mutex.release()

6.例如：使用互斥鎖完成2個執行緒對同乙個全域性變數各加100萬次的操作

import

threading
import
time
g_num =0
deftest1(num):
global
g_num
for i in
range(num):
mutex.acquire()  #上鎖
g_num += 1mutex.release()  #解鎖
print("
---test1---g_num=%d
"%g_num)
deftest2(num):
global
g_num
for i in
range(num):
mutex.acquire()  #上鎖
g_num += 1mutex.release()  #解鎖
print("
---test2---g_num=%d
"%g_num)
#建立乙個互斥鎖
#預設是未上鎖的狀態
mutex =threading.lock()
#建立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)

加了互斥鎖就不會出現資源競爭而導致結果與理想不合。

多工 執行緒

建立函式 建立執行緒物件，並制定函式 開啟執行緒 import threading import time defwork1 1.定義函式 for i in range 5 print 正在掃地 i time.sleep 1 defmain 測試執行緒的基本使用 2.建立執行緒物件 t1 threa...

多工 執行緒

簡單地說，就是作業系統可以同時執行多個任務。實現多工有多種方式，執行緒 程序 協程。可以簡單理解為同一程序中有多個計數器，每個執行緒的執行時間不確定，而每個程序的時間片相等，執行緒是作業系統排程執行的最小單位.import threadingt1 threading.thread target fu...

多工 執行緒

什麼叫 多工 呢？簡單地說，就是作業系統可以同時執行多個任務。執行緒 1.使用threading模組 import threading defsing pass defdance pass defmain t1 threading.thread target sing t2 threading.th...