Synchronization utility to manage locks

[JSL5101]

Hey folks,

Say I have the following:

public void doSomething(Integer myObjID, String val) throws CustomException {
     MyObject myObj = getTheObject(myObjID); // get object from the database
     if(null == myObj.getVal()){
           myObj.setVal(val);
           saveTheObject(myObj); // save to database
     }
     else{
           throw new CustomException("The object with the given id already has a val.");
     }
}

I am trying to handle concurrent calls to this method based on the id, meaning, concurrent calls to this method for the same ID should block, but concurrent calls to this method for different IDs should not block.

I am trying to find something like:

public void doSomething(int myObjID, String val) throws CustomException {
          
     MyObjLock idBasedLock = Utility.getOrCreateLock(myObjID);
     synchronized(idBasedLock){
 
         MyObject myObj = getTheObject(myObjID); // get object from the database
          if(null == myObj.getVal()){
              myObj.setVal(val);
              saveTheObject(myObj); // save to database
          }
          else{
              throw new CustomException("The object with the given id already has a val.");
          }
     }
}

What I am thinking is that the Utility class creates locks for invocations of the method. Since the program is running indefinitely, locks need to be created and destroyed during the program execution.

Since concurrent calls for the same ID need the same lock, the Utility class either:

1. creates the lock, stores it in memory, then returns it
2. returns the lock if it already exists

Since locks are created at runtime, the Utility class needs to have a way to get rid of the locks that are not being used. For example, if two concurrent calls for the same ID come in, the Utility class does 1 and 2 above. When the two threads finish running, we don't know how long it will be until another call comes in for the same ID, so the lock must be disposed.

I don't have a lot of experience with synchronization, but I was wondering if this is possible? I think it might be safer to have the database handle the concurrency issues around the field value, but the initial problem lead me to think about how to handle synchronization based on the value of a field on the fly.

I was thinking about having a ConcurrentHashMap keyed on an Integer:

public final class Utility {
   private ConcurrentHashMap<Integer, Object> keyMap = new ConcurrentHashMap<Integer, Object>();
   private Utility(){ // empty }

   public static MyObjLock getOrCreateLock(Integer id){
        keyMap.putIfAbsent(id, new MyObjLock());
        return keyMap.get(id);
   }

   // some deamon thread to remove locks that are not being used from keyMap
}

With this kind of implementation, I am thinking the the actual lock object needs some kind of counter that indicates how many threads are using it.

What I also thought of doing was using a WeakHashMap, but I have never worked with them before and it would have to deal with synchronization.

Any thoughts? Does this make any sense or am I off my rocker?

[shnplr]

Hi,

This approach doesn't work in a clustered environment (multiple servers/JVM's).

Can you change your update statement to check for null?

update my_table
set val = :val
where my_id = :id and val is null