什麼是執行緒
程序:資源分配單位
執行緒:cpu執行單位(實體),每乙個py檔案中就是乙個程序,乙個程序中至少有乙個執行緒
執行緒的兩種建立方式:
from multiprocessing import二process
deff1(n):
print(n,'
號執行緒')if
__name__ == '
__main__':
t1 = thread(target=f1,args=(1,))
t1.start()
print('
主線程')
from threading import執行緒的建立和銷毀,相對於程序來說開銷特別小thread
class
mythread(thread):
def__init__
(self,name):
super().
__init__
() self.name =name
defrun(self):
print('
hello:
' +self.name)
if__name__ == '
__main__':
t = mythread('
haha')
t.start()
print('
主線程結束
')
執行緒之間資源共享,共享的是同乙個程序中的資源, 資源共享就涉及到資料安全問題,加鎖來解決
執行緒鎖
from threading import thread,lock
def f1:
loc.acquire()
**loc.release()
main
loc = lock()
t = thread(target=f1,args=(loc,)
from multiprocessing import鎖:犧牲了效率,保證了資料安queue
import
queue
import
time
from threading import
lock,thread
num = 100
deff1(loc):
loc.acquire()
global
num tmp =num
tmp -= 1time.sleep(0.001)
num =tmp
loc.release()
if__name__ == '
__main__':
t_loc =lock()
t_list =
for i in range(10):
t = thread(target=f1,args=(t_loc,))
t.start()
[tt.join()
for tt in
t_list]
print('
主線的num
',num)
死鎖現象(天長地久,永不分離):
出現在鎖巢狀的時候,雙方互相搶對方已經拿到的鎖,導致雙方互相等待,這就是死鎖現象
import遞迴鎖:解決死鎖現象time
from threading import
thread,lock,rlock
deff1(loca,locb):
loca.acquire()
print('
f1>>1號搶到了a鎖')
time.sleep(1)
locb.acquire()
print('
f1>>1號搶到了b鎖')
locb.release()
loca.release()
deff2(loca,locb):
locb.acquire()
print('
f2>>2號搶到了b鎖')
loca.acquire()
time.sleep(1)
print('
f2>>2號搶到了a鎖')
loca.release()
locb.release()
if__name__ == '
__main__':
loca =lock()
locb =lock()
t1 = thread(target=f1,args=(loca,locb))
t2 = thread(target=f2,args=(loca,locb))
t1.start()
t2.start()
rlock 首先本身就是個互斥鎖,維護了乙個計數器,每次acquire就+1,release就-1,當計數器為0的時候,大家才能搶這個鎖
import守護執行緒:守護執行緒:等待所有非守護執行緒的結束才結束time
from threading import
thread, lock, rlock
deff1(loca, locb):
loca.acquire()
print('
f1>>1號搶到了a鎖')
time.sleep(1)
locb.acquire()
print('
f1>>1號搶到了b鎖')
locb.release()
loca.release()
deff2(loca, locb):
locb.acquire()
print('
f2>>2號搶到了b鎖')
loca.acquire()
time.sleep(1)
print('
f2>>2號搶到了a鎖')
loca.release()
locb.release()
if__name__ == '
__main__':
loca = locb =rlock()
t1 = thread(target=f1, args=(loca, locb))
t2 = thread(target=f2, args=(loca, locb))
t1.start()
t2.start()
守護程序:主程序**執行結束,守護程序就隨之結束
import timegil鎖 :cpython直譯器上的一把互斥鎖,當執行緒需要進入cpu做運算時必須乙個乙個經過gil鎖from threading import thread
from multiprocessing import process
def f1():
time.sleep(2)
print('1號執行緒')
def f2():
time.sleep(3)
print('2號執行緒')
if __name__ == '__main__':
t1 = thread(target=f1,)
t2 = thread(target=f2,)
t2.daemon = true
t1.start()
t2.start()
print('主線程結束')
執行緒的事件,訊號量 與程序的事件,訊號量 用法相同.
Python併發程式設計 執行緒鎖
多執行緒中雖然有gil,但是還是有可能產生資料不安全,故還需加鎖 from threading import lock,thread 互斥鎖 import time def eat1 lock global n lock.acquire temp n time.sleep 0.2 n temp 1 ...
併發程式設計整理筆記06 讀寫鎖
public class readwritelocktest string.valueof i start for int i 1 i 5 i string.valueof i start class mycache public void get string key class mycachel...
併發程式設計之執行緒的讀寫鎖
1.概念 2.讀寫鎖的狀態 3.讀寫鎖特性 4.讀寫鎖的適用場景 5.主要資料型別和應用函式 6.編碼舉例 讀寫鎖實際上是一種特殊的自旋鎖,它把共享資源的訪問劃分成讀者和寫者,讀者只能擁有對共享資源的讀許可權,寫者則需要對共享資源進行寫操作。讀寫鎖並不是兩把鎖,它是乙個名字叫做讀寫鎖的鎖,可以擁有讀...