。即使在python多線程環境中調用release（）後，.locked（）也會返回True

Question

我試圖用python線程編寫我的第一個代碼。

請參閱代碼 有當我釋放鎖使用釋放（）線程的問題，因爲它說的鎖仍然是速效[鎖定（）甚至發佈後返回True（）]

import threading 
import time 

class thread (threading.Thread): 
    def __init__(self,t,d,arr,lock): 
     threading.Thread.__init__(self) 
     self.name=t 
     self.delay=d 
     self.array=arr; 
     self.lock=lock 
    def run(self): 
     self.fun1() 


    def fun1(self): 
     print "the thread %s want to take a lock now" %self.name 
     self.lock.acquire() 
     print "lock status just after lock acquire foe",self.name,self.lock.locked() 

     time.sleep(self.delay) 

     print "release lock for %s" %self.name 
     self.lock.release() 
     time.sleep(2) 
     print "lock status after lock release is",self.name,self.lock.locked() 
lck=threading.Lock() 
obj1=thread('T1',5,[1,2,3],lck) 
obj2=thread('T2',10,[4,5,6],lck) 


obj1.start() 
obj2.start() 

輸出

===== 
    the thread T1 want to take a lock now 
the thread T2 want to take a lock now 

lock status just after lock acquire foe T2 True 
release lock for T2 
lock status just after lock acquire foe T1 True 
lock status after lock release is T2 True 
release lock for T1 
lock status after lock release is T1 False 

我的問題是什麼：

線程T2第一次拿到了鎖，並執行它的空間。 我們可以使用.locked（）查看T2的鎖定狀態。「鎖定狀態剛好在

鎖定獲取對象T2 True」。所以T2現在鎖定了。 一旦T2發佈使用release（）的鎖，那麼T1也按預期獲得了鎖

但是在使用release（）鎖定釋放T2後，locked（）表示爲True。這意味着仍然鎖定可用於T2？在這種情況下，T1如何獲得鎖定？一旦執行了T1並釋放後（），我就可以看到.locked（）返回False。意味着T1的鎖定（）工作如預期，因爲一旦它釋放鎖定，立即返回False

因此，簡而言之，爲什麼我的第一個線程T2即使在其釋放鎖後也返回True？ 如果我只執行1個線程，它按預期工作。

Answer 1

當您將鎖對象傳遞給構造函數時，它不會被複制，因此每個線程對象都可以訪問與鎖相同的鎖。

這導致self.lock.locked()返回True因爲鎖仍然鎖定，但此時它已被另一個線程鎖定。

這是實際發生的事情：

>>> import threading 
>>> lck = threading.Lock() # the 'original' 
>>> lck2 = lck # lck2 isn't a copy of lck! 
>>> lck.acquire() 
True 
>>> lck2.locked() # lck2 has been acquired as well as lck 
True 
>>> lck2.release() 
>>> lck.locked() # lck has been released as well as lck2 
False 

再次，這是因爲鎖定的對象是沒有（不能）複製周圍，任何變量分配給一些鎖，它會點到原始對象。