मुख्य अंतर यह है कि एक Lock केवल एक बार प्राप्त किया जा सकता है। इसे तब तक हासिल नहीं किया जा सकता जब तक इसे जारी नहीं किया जाता है। (इसे जारी करने के बाद, इसे किसी भी थ्रेड द्वारा पुनः प्राप्त किया जा सकता है)।
दूसरी ओर एक RLock, उसी धागे से कई बार अधिग्रहित किया जा सकता है। "अनलॉक" होने के लिए इसे कई बार जारी किया जाना चाहिए।
एक और अंतर यह है कि एक अधिग्रहित Lock किसी भी थ्रेड द्वारा जारी किया जा सकता है, जबकि एक अधिग्रहण RLock केवल इसे प्राप्त किए गए थ्रेड द्वारा जारी किया जा सकता है।
यहां उदाहरण दिया गया है कि RLock कभी-कभी उपयोगी क्यों होता है। मान लीजिए आप है:
def f():
g()
h()
def g():
h()
do_something1()
def h():
do_something2()
के f, g के सभी मान लें, और hसार्वजनिक (अर्थात एक बाहरी कॉल करने वाले को सीधे कहा जा सकता है) कर रहे हैं, और उन सभी समन्वयन की आवश्यकता है।
एक Lock उपयोग करके, आप की तरह कुछ कर सकते हैं:
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()
मूल रूप से, के बाद से f ताला प्राप्त करने के बाद g कॉल नहीं कर सकते, यह g की एक "कच्चे" संस्करण (अर्थात _g) कॉल करने के लिए की जरूरत है। तो आप एक "समन्वयित" संस्करण और प्रत्येक समारोह के "कच्चे" संस्करण के साथ समाप्त होते हैं।
lock = RLock()
def f():
with lock:
g()
h()
def g():
with lock:
h()
do_something1()
def h():
with lock:
do_something2()
:
एक RLock का उपयोग करते हुए सुंदर ढंग से समस्या का हल