public Class WriteLockManager

INTERNAL: This is a recursive method used to acquire read locks on all objects that will be cloned. These include all related objects for which there is no indirection. The returned object is the first object that the lock could not be acquired for. The caller must try for exceptions and release locked objects in the case of an exception.

INTERNAL: This method will return once the object is locked and all non-indirect related objects are also locked.

INTERNAL: This method will be the entry point for threads attempting to acquire locks for all objects that have a changeset. This method will hand off the processing of the deadlock algorithm to other member methods. The mergeManager must be the active mergemanager for the calling thread. Returns true if all required locks were acquired This is wrapper method with semaphore logic.

The thread was doing its while loop to acquire all required locks to proceed with the commmit and it realized there was one cache key it is unable to acquire

Parameters

thread:Thread

thread the thread working on updating the shared cache

cacheKeyThatCouldNotBeAcquired:ConcurrencyManager

the cache key it is not managing to acquire

Exceptions

InterruptedException:

Should be fired because we are passing a flag into the determineIfReleaseDeferredLockAppearsToBeDeadLocked to say we do not want the thread to be blown up (e.g. we are afraid of breaking threads in the middle of a commit process could be quite dangerous). See ALLOW_INTERRUPTED_EXCEPTION_TO_BE_FIRED_UP_FALSE

INTERNAL: This method will be called by a merging thread that is attempting to lock a new object that was not locked previously. Unlike the other methods within this class this method will lock only this object.

Remove the current thread from the map of object ids with change sets that are about to bec ommited

Parameters

thread:Thread

the thread that is clearing itself out of the map of change sets it needs to merge into the shared cache

Before the problematic while loop starts we should always clear for this thread the set of cache keys it could not acquire.

Parameters

thread:Thread

the thread that what clear his set of cache keys it is struggling to acquire.

Getter for MAP_WRITE_LOCK_MANAGER_THREAD_TO_OBJECT_IDS_WITH_CHANGE_SET

Getter for THREAD_TO_FAIL_TO_ACQUIRE_CACHE_KEYS

Before a thread starts long wait loop to acquire write locks during a commit transaction the thread will record in this map the object ids it holds with chance sets. It will be useful information if a dead lock is taking place.

Parameters

thread:Thread

the thread that is in the middle of merge to the shared cache trying to acquire write locks to do this merge

objectChangeSets:Collection<ObjectChangeSet>

the object change sets it has in its hands and that it would like to merge into the cache

INTERNAL: This method will release all acquired locks

A cache keys was successfully acquired we want to make sure it is not recorded in the map of cache keys that could not be acquired. The situation theoretically can change. Failing to acquire a write lock can be a temporary situation. The lock might become available eventually. Otherwise there would be no point for the while loop that is trying to acquire these locks.

Parameters

thread:Thread

the thread that just managed to grab a write lock

cacheKeyThatCouldNotBeAcquired:ConcurrencyManager

the cache key it managed to acquire for writing.

INTERNAL: This method will transition the previously acquired active locks to deferred locks in the case a readlock could not be acquired for a related object. Deferred locks must be employed to prevent deadlock when waiting for the readlock while still protecting readers from incomplete data.

INTERNAL: Traverse the object and acquire locks on all related objects.