org.hibernate.cache
Class ReadWriteCache
java.lang.Object
org.hibernate.cache.ReadWriteCache
- CacheConcurrencyStrategy
public class ReadWriteCache
extends java.lang.Object
Caches data that is sometimes updated while maintaining the semantics of
"read committed" isolation level. If the database is set to "repeatable
read", this concurrency strategy almost maintains the semantics.
Repeatable read isolation is compromised in the case of concurrent writes.
This is an "asynchronous" concurrency strategy.
If this strategy is used in a cluster, the underlying cache implementation
must support distributed hard locks (which are held only momentarily). This
strategy also assumes that the underlying cache implementation does not do
asynchronous replication and that state has been fully replicated as soon
as the lock is released.
boolean | afterInsert(Object key, Object value, Object version) - Add the new item to the cache, checking that no other transaction has
accessed the item.
|
boolean | afterUpdate(Object key, Object value, Object version, SoftLock clientLock) - Re-cache the updated state, if and only if there there are
no other concurrent soft locks.
|
void | clear()
|
void | destroy()
|
void | evict(Object key) - Do nothing.
|
Object | get(Object key, long txTimestamp) - Do not return an item whose timestamp is later than the current
transaction timestamp.
|
Cache | getCache()
|
String | getRegionName()
|
boolean | insert(Object key, Object value, Object currentVersion) - Do nothing.
|
SoftLock | lock(Object key, Object version) - Stop any other transactions reading or writing this item to/from
the cache.
|
boolean | put(Object key, Object value, long txTimestamp, Object version, Comparator versionComparator, boolean minimalPut) - Do not add an item to the cache unless the current transaction
timestamp is later than the timestamp at which the item was
invalidated.
|
void | release(Object key, SoftLock clientLock) - Release the soft lock on the item.
|
void | remove(Object key)
|
void | setCache(Cache cache)
|
String | toString()
|
boolean | update(Object key, Object value, Object currentVersion, Object previousVersion) - Do nothing.
|
ReadWriteCache
public ReadWriteCache()
get
public Object get(Object key,
long txTimestamp)
throws CacheException
Do not return an item whose timestamp is later than the current
transaction timestamp. (Otherwise we might compromise repeatable
read unnecessarily.) Do not return an item which is soft-locked.
Always go straight to the database instead.
Note that since reading an item from that cache does not actually
go to the database, it is possible to see a kind of phantom read
due to the underlying row being updated after we have read it
from the cache. This would not be possible in a lock-based
implementation of repeatable read isolation. It is also possible
to overwrite changes made and committed by another transaction
after the current transaction read the item from the cache. This
problem would be caught by the update-time version-checking, if
the data is versioned or timestamped.
- get in interface CacheConcurrencyStrategy
lock
public SoftLock lock(Object key,
Object version)
throws CacheException
Stop any other transactions reading or writing this item to/from
the cache. Send them straight to the database instead. (The lock
does time out eventually.) This implementation tracks concurrent
locks of transactions which simultaneously attempt to write to an
item.
- lock in interface CacheConcurrencyStrategy
put
public boolean put(Object key,
Object value,
long txTimestamp,
Object version,
Comparator versionComparator,
boolean minimalPut)
throws CacheException
Do not add an item to the cache unless the current transaction
timestamp is later than the timestamp at which the item was
invalidated. (Otherwise, a stale item might be re-added if the
database is operating in repeatable read isolation mode.)
For versioned data, don't add the item unless it is the later
version.
- put in interface CacheConcurrencyStrategy
release
public void release(Object key,
SoftLock clientLock)
throws CacheException
Release the soft lock on the item. Other transactions may now
re-cache the item (assuming that no other transaction holds a
simultaneous lock).
- release in interface CacheConcurrencyStrategy
toString
public String toString()
update
public boolean update(Object key,
Object value,
Object currentVersion,
Object previousVersion)
Do nothing.
- update in interface CacheConcurrencyStrategy