StaticCacheKeyLock (Gemma 1.31.6 API)

java.lang.Object
- ubic.gemma.persistence.cache.StaticCacheKeyLock

All Implemented Interfaces:

CacheKeyLock
```
public class StaticCacheKeyLock
extends Object
implements CacheKeyLock
```
Implementation of the CacheKeyLock interface that uses a static week map to store locks by key.
Locks are guaranteed to be kept around as long as there is a CacheKeyLock.LockAcquisition referring to it, otherwise they might be freed by the GC.

Author:

poirigui

See Also:

WeakHashMap

Nested Class Summary
- Nested classes/interfaces inherited from interface ubic.gemma.persistence.cache.CacheKeyLock
  CacheKeyLock.LockAcquisition

Constructor Summary

Constructors
Constructor Description

StaticCacheKeyLock(Cache cache, Object key, boolean readOnly)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`boolean`	`isReadOnly()`	Indicate if this lock is read-only.
`CacheKeyLock.LockAcquisition`	`lock()`	Acquire a lock on the cache key.
`CacheKeyLock.LockAcquisition`	`lockInterruptibly()`	Acquire a lock interruptibly on a cache key.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - StaticCacheKeyLock
```
public StaticCacheKeyLock(Cache cache,
                          Object key,
                          boolean readOnly)
```
- Method Detail
  - isReadOnly
```
public boolean isReadOnly()
```
    Description copied from interface: CacheKeyLock
    
    Indicate if this lock is read-only.
    
    Specified by:
    
    isReadOnly in interface CacheKeyLock
  - lock
```
public CacheKeyLock.LockAcquisition lock()
```
    Description copied from interface: CacheKeyLock
    
    Acquire a lock on the cache key.
    
    Specified by:
    
    lock in interface CacheKeyLock
  - lockInterruptibly
```
public CacheKeyLock.LockAcquisition lockInterruptibly()
                                               throws InterruptedException
```
    Description copied from interface: CacheKeyLock
    
    Acquire a lock interruptibly on a cache key.
    
    Specified by:
    
    lockInterruptibly in interface CacheKeyLock
    
    Throws:
    
    InterruptedException - if the current thread was interrupted prior to or while waiting on the lock