Was ist der Unterschied zwischen Schloss und RLOCK

Question

Vom docs:

threading.RLock() - Eine Fabrik-Funktion, die eine neue einspringenden Lock-Objekt zurückgibt. Eine Wiedereintrittssperre muss von dem Thread, der sie erworben hat, freigegeben werden. Sobald ein Thread eine Wiedereintrittssperre erworben hat, kann der gleiche Thread diese erneut ohne Blockade erfassen. Der Thread muss es für jedes Mal, wenn es es erworben hat, einmal freigeben.

Ich bin nicht sicher, warum brauchen wir das? Was ist der Unterschied zwischen Rlock und Lock?

dank

Answer 1

Der wesentliche Unterschied besteht darin, dass ein Lock kann nur einmal erworben werden. Es kann nicht wieder erworben werden, bis es freigegeben wird. (Nachdem es freigegeben wurde, kann es von jedem Thread erneut akquiriert werden).

Eine RLock auf der anderen Seite, kann mehrmals erworben werden, durch den gleichen Thread. Es muss genauso oft freigegeben werden, um "freigeschaltet" zu werden.

Ein weiterer Unterschied ist, dass ein erworbenes Lock von einem beliebigen Thread freigegeben werden kann, während ein erworbenes RLock nur von dem Thread freigegeben werden kann, die es erworben hat.

---

Hier ist ein Beispiel demostrating warum RLock manchmal nützlich ist. Angenommen, Sie haben:

def f(): 
    g() 
    h() 

def g(): 
    h() 
    do_something1() 

def h(): 
    do_something2() 

Lassen Sie uns alle sagen von f, g und h sind öffentlichen (das heißt direkt von einem externen Anrufer genannt werden), und alle von ihnen benötigen syncronization.

ein Lock verwenden, können Sie wie etwas tun:

lock = Lock() 

def f(): 
    with lock: 
    _g() 
    _h() 

def g(): 
    with lock: 
    _g() 

def _g(): 
    _h() 
    do_something1() 

def h(): 
    with lock: 
    _h() 

def _h(): 
    do_something2() 

Grundsätzlich seit f nicht g nach dem Erwerb der Sperre aufrufen können, braucht es eine „rohe“ Version von g (das heißt _g) zu nennen. Sie haben also eine "synchronisierte" Version und eine "rohe" Version jeder Funktion.

ein RLock elegant Mit löst das Problem:

lock = RLock() 

def f(): 
    with lock: 
    g() 
    h() 

def g(): 
    with lock: 
    h() 
    do_something1() 

def h(): 
    with lock: 
    do_something2()