###############總結############

線程創建的2種方式(重點)

進程:資源分配單位 線程:cpu執行單位(實體)

線程的創建和銷毀的開銷特別小

線程之間資源共享,是同一個進程中的資源共享,會涉及到安全問題,所以需要加鎖解決

鎖:犧牲了效率,保證了數據安全(重點)

死鎖現象:出現在嵌套的時候,雙方互相搶對方已經拿到的鎖,導致雙方互相等待(重點)

遞歸鎖: 解決了死鎖現象(重點)

　　rlock 首先本身就是個互斥鎖,維護了一個計數器,每次acquire+1,release就-1,當計數器為0的時候,大家才會搶這個鎖

守護線程:

　　守護線程:等待所有非守護線程結束才結束

　　守護進程: 主進程運行代碼結束,守護進程會隨之結束

GIL鎖:

###第一種
from threading import Thread
def f1(n):
    print(n)
if __name__ == ‘__main__‘:
    t1=Thread(target=f1,args=(1,))
    t1.start()
###第二種
class mythread(Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        
 
print(‘hellow‘+self.name)
if __name__ == ‘__main__‘:
    t=mythread(‘alex‘)
    t.start()
    print(‘主線程結束‘)

###查看線程的進程id

import os
from  threading import Thread
def f1(n):
    print(‘1號‘,os.getpid())
    print(‘%s號‘%n)
def f2(n):
    print(‘2號‘,os.getpid())
    print(‘%s‘%n)
if __name__ == ‘__main__
 
‘:
    t1=Thread(target=f1,args=(1,))
    t2=Thread(target=f2,args=(2,))
    t1.start()
    t2.start()
    print(‘主進程id‘,os.getpid())
############
線程ID是一樣的

###驗證線程是數據共享的

import os
import time
from threading import Thread
num=100
def f1(n):
    global num
    num=3
    print(‘子線程num‘,num)
if __name__ == ‘__main__‘:
    t=Thread(target=f1,args=(1,))
    t.start()
    t.join()#主進程等待子進程運行完才繼續執行
    print(‘主進程的num‘,num)
###################

子線程num 3
主進程的num 3

###多進程效率對比

import time
from threading import Thread
from multiprocessing import Process
def f1():
    for i in range(5):
        i=i+i
if __name__ == ‘__main__‘:
    t_s_time=time.time()
    t_list=[]
    # 查看一下20個線程執行20個任務的執行時間
    for i in range(20):
        t=Thread(target=f1,)
        t.start()
        t_list.append(t)
    [tt.join() for tt in t_list]
    t_e_time=time.time()
    t_dif_time=t_e_time-t_s_time
    # print(t_dif_time)
    #查看一個20個進程執行的任務時間
##########################################
    p_s_time=time.time()
    p_list=[]
    for i in range(20):
        p=Process(target=f1,)
        p.start()
        p_list.append(p)
    [pp for pp in p_list]
    p_e_time=time.time()
    p_dif_time=p_e_time-p_s_time
    print(‘線程執行的時間%s‘%t_dif_time)
    print(‘進程執行的時間%s‘ % p_dif_time)
###################
線程執行的時間0.003000497817993164
進程執行的時間0.2560145854949951

####鎖

import time
from multiprocessing import Process
from threading import Thread,Lock
num=100
def f1(loc):
    loc.acquire()
    global num
    tmp=num
    tmp-=1
    time.sleep(0.01)#模擬
    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()
        t_list.append(t)
    [tt.join() for tt in t_list]
    print(‘主進程‘,num)
##############
主進程 90

#####死鎖現象

import time
from threading import Thread,Lock,RLock
def f1(locA,locB):
    locA.acquire()
    print(‘f1>>1號搶到了A鎖‘)
    time.sleep(1)
    locB.acquire()
    print(‘f1>>1號搶到了B鎖‘)
    locB.release()
    locA.release()
def f2(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()
##################
f1>>1號搶到了A鎖
f2>>2號搶到了B鎖

python 線程(創建2種方式,守護進程,鎖,死鎖,遞歸鎖,GIL鎖,其他方式)