Difference between Lock and Rlock objects-Python

When working with multithreading in Python, Lock and RLock are two commonly used synchronization mechanisms to ensure mutual exclusion. Both are part of the threading module but behave differently. The key difference is that Lock can only be acquired once by a thread, whereas RLock allows the same thread to acquire the lock multiple times. Example:

import threading

lock = threading.Lock() # Lock
lock.acquire()
print("Lock acquired")
lock.release()

rlock = threading.RLock() # RLock
rlock.acquire()
print("RLock acquired once")
rlock.acquire()
print("RLock acquired twice")
rlock.release()
rlock.release()

Lock acquired
RLock acquired once
RLock acquired twice

Explanation:

• threading.Lock() initializes the lock, lock.acquire() acquires it and lock.release() releases it for other threads.
• threading.RLock() initializes an RLock, rlock.acquire() acquires it twice and rlock.release() releases it twice.

What is a Lock ?

A Lock is a synchronization tool provided by the threading module in Python. It is used to ensure that only one thread can access a shared resource (such as a file or variable) at a time. Let's understand its key features:

• Mutual Exclusion: Only one thread can hold the lock at a time.
• Blocking Behavior: Threads attempting to acquire a locked lock will wait until it's released.
• Not Reentrant: A thread cannot acquire the same lock twice without releasing it, leading to deadlock.

import threading

lock = threading.Lock()
geek = 0 # global variable

def fun(value):
    global geek
    with lock:
        geek += value
        
fun(1)
fun(2)

print(geek)

3

Explanation:

• threading.Lock() creates a lock to ensure only one thread can modify the shared resource geek at a time.
• fun(value) increments geek by the given value, using with lock to ensure mutual exclusion, so only one thread can update geek at a time.
• fun(1) increments geek by 1, releases the lock and geek becomes 1.
• fun(2) increments geek by 2, releases the lock and geek becomes 3.

What is RLock(Reentrant Lock)?

An RLock (Reentrant Lock) is a specialized type of lock in Python’s threading module that allows a thread to acquire the same lock multiple times without causing a deadlock. It is designed to solve the problem of reentrancy, where a thread may need to acquire a lock again while already holding it. Let's understand its key features:

• Reentrant: A thread can acquire the lock multiple times without blocking itself.
• Acquisition Counter: RLock tracks how many times it’s acquired by the same thread.
• Release Requirement: The thread must call release() the same number of times it called acquire() to fully release the lock.

import threading

geek = 0
rlock = threading.RLock()

def fun():
    global geek
    rlock.acquire()  # First acquisition
    geek += 1
    rlock.acquire()  # Second acquisition
    geek += 2
    rlock.release()  # Release first
    rlock.release()  # Release second

thread = threading.Thread(target=fun)
thread.start()
thread.join()

print(geek)

3

Explanation:

• threading.RLock() allows the same thread to acquire the lock multiple times without deadlock.
• rlock.acquire() locks the resource, and geek is incremented by 1.
• The same thread acquires the lock again, incrementing geek by 2.
• rlock.release() is called twice to release the lock, ensuring proper resource management.

Difference between Lock and Rlock

Understanding the difference between Lock and RLock is important for safe multithreading. These synchronization mechanisms ensure proper access to shared resources but behave differently in certain scenarios. Let's explore these differences through the following table: