DEV Community

Hitesh Chawla
Hitesh Chawla

Posted on

R-Lock vs Lock in Python

In Python, both Lock and RLock are synchronization primitives provided by the threading module to manage access to shared resources in multithreaded programs. However, they differ in their behavior and use cases.


1. Lock (threading.Lock)

  • Description: A Lock is a simple locking mechanism that allows only one thread to acquire the lock at a time. Once a thread acquires the lock, any other thread trying to acquire it will block until the lock is released.
  • Non-reentrant: A thread that already holds the lock cannot acquire it again until it releases it. If it attempts to do so, it will cause a deadlock.
  • Use Case: Use Lock when a thread only needs to acquire the lock once and release it after finishing its work.

Example of Lock:

import threading

lock = threading.Lock()

def critical_section():
    lock.acquire()
    try:
        print(f"{threading.current_thread().name} is in the critical section")
    finally:
        lock.release()

thread1 = threading.Thread(target=critical_section)
thread2 = threading.Thread(target=critical_section)

thread1.start()
thread2.start()
thread1.join()
thread2.join()
Enter fullscreen mode Exit fullscreen mode

2. RLock (threading.RLock)

  • Description: A Reentrant Lock (RLock) is a more sophisticated lock that allows the same thread to acquire the lock multiple times without causing a deadlock. Each acquire must be paired with a corresponding release.
  • Reentrant: A thread can re-acquire the lock it already holds as long as it releases it the same number of times.
  • Use Case: Use RLock when a thread may need to acquire the same lock multiple times, for example, in recursive functions or when one lock-protected operation calls another lock-protected operation.

Example of RLock:

import threading

rlock = threading.RLock()

def recursive_function(count):
    rlock.acquire()
    try:
        print(f"{threading.current_thread().name} acquired the lock: count = {count}")
        if count > 0:
            recursive_function(count - 1)  # Recursive call acquires the lock again
    finally:
        rlock.release()

thread = threading.Thread(target=recursive_function, args=(3,))
thread.start()
thread.join()
Enter fullscreen mode Exit fullscreen mode

Key Differences Between Lock and RLock

Feature Lock (threading.Lock) RLock (threading.RLock)
Reentrancy Not reentrant (deadlock if re-acquired by the same thread). Reentrant (same thread can acquire multiple times).
Use Case Simple locking mechanisms without nested or recursive locking. Recursive locking or nested locking scenarios.
Performance Slightly faster and simpler. Slightly more overhead due to reentrancy support.

When to Use Which?

  • Use Lock for simpler cases where reentrancy is not required.
  • Use RLock if you anticipate scenarios where a thread may need to re-acquire the same lock, such as recursive function calls or nested lock usage.
Retry later

Top comments (0)

Retry later
Retry later