Multithreading : RLock (Reentrant) objects

Python Multithread

A code is re-entrant if it can be safely called again. In other words, re-entrant code can be called more than once, even though called by different threads, it still works correctly. So, the re-entrant section of code usually use local variables only in such a way that each and every call to the code gets its own unique copy of data.

Re-entrant methods are more constrained than thread-safe methods. This is because it is safe to call re-entrant methods simultaneously from multiple threads only if each invocation results only in unique data being accessed, such as local variables.

1. Non-entrant code:
   

   g = 1
   
   def f1():
     g = g + 2;
     return g;
   
   def f2():
     return f1() + 2;
   

   If two concurrent threads access g_var, the result depends on the time of execution of each thread.

2. Re-entrant code:
   

   def f(i): 
      return i + 2 
   
   def h(i): 
      return f(i) + 2; 
   

Normal Lock objects cannot be acquired more than once, even by the same thread. This can introduce undesirable side-effects if a lock is accessed by more than one function in the same call chain:

import threading

lock = threading.Lock()

print 'First try :', lock.acquire()
print 'Second try:', lock.acquire(0)
print "print this if not blocked..."

Output:

First try : True
Second try: False
print this if not blocked...

As we can see from the code, since both functions are using the same global lock, and one calls the other, the second acquisition fails and would have blocked using the default arguments to acquire(blocking=True, timeout=-1) as shown in the following code and output:

import threading

lock = threading.Lock()

print 'First try :', lock.acquire()
print 'Second try:', lock.acquire()

print "print this if not blocked..."

This code is blocking:

First try : True
Second try:

So, as in the example above, in a situation where separate code from the same thread needs to "re-acquire" the lock, we need to use an threading.RLock instead of a simple threading.Lock():

import threading

lock = threading.RLock()

print 'First try :', lock.acquire()
print 'Second try:', lock.acquire(0)

Output shows that we're able to "re-acquire" the lock:

First try : True
Second try: 1

Python Multithread