Question

How can I implement conditional lock in threaded application, for instance I haw 30 threads that are calling function and for most off the time all threads can access is simultaneous, but depending on function input there can be condition when only one thread can do that one thing. (If value for input is repeated and some thread is still working then I need lock.)

I now that there is module threading with Rlock() but I don’t now how to use it in a way that i described it in first part.

Edit: The question is actually about how to prevent any two threads from running the same function with the same argument at the same time. (Thanks to David for helping me formulate my question 🙂 )

Answer 1

Try this: have a lock in the module where your function is, and if the input to the function is such that locking is required, acquire the lock inside the function. Otherwise don’t.

l = threading.RLock()  def fn(arg):     if arg == arg_that_needs_lock:         l.acquire()         try:             # do stuff         finally:             l.release()     else:         # do other stuff 

---

EDIT:

As far as I can tell now, the question is actually about how to prevent any two threads from running the same function with the same argument at the same time. There’s no problem with two threads running the same function with different arguments at the same time, though. The simple method to do this, if all valid arguments to the function can be dictionary keys, is to create a dictionary of arguments to locks:

import threading  dict_lock = threading.RLock() locks = {}  def fn_dict(arg):     dict_lock.acquire()     try:         if arg not in dict:             locks[arg] = threading.RLock()         l = locks[arg]     finally:         dict_lock.release()     l.acquire()     try:         # do stuff     finally:         l.release() 

If your function can be called with many different arguments, though, that amounts to a lot of locks. Probably a better way is to have a set of all arguments with which the function is currently executing, and have the contents of that set protected by a lock. I think this should work:

set_condition = threading.Condition() current_args = set()  def fn_set(arg):     set_condition.acquire()     try:         while arg in current_args:             set_condition.wait()         current_args.add(arg)     finally:         set_condition.release()     # do stuff     set_condition.acquire()     try:         current_args.remove(arg)         set_condition.notifyAll()     finally:         set_condition.release()