public class

ReadWriteCache

extends Object
implements CacheConcurrencyStrategy
java.lang.Object
   ↳ org.hibernate.cache.ReadWriteCache

Class Overview

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.

See Also

Summary

Nested Classes
class ReadWriteCache.Item An item of cached data, timestamped with the time it was cached,. 
class ReadWriteCache.Lock A soft lock which supports concurrent locking, timestamped with the time it was released 
interface ReadWriteCache.Lockable  
Public Constructors
ReadWriteCache()
Public Methods
synchronized boolean afterInsert(Object key, Object value, Object version)
Add the new item to the cache, checking that no other transaction has accessed the item.
synchronized 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()
Evict all items from the cache immediately.
void destroy()
Clean up all resources.
void evict(Object key)
Do nothing.
synchronized Object get(Object key, long txTimestamp)
Do not return an item whose timestamp is later than the current transaction timestamp.
Cache getCache()
Get the wrapped cache implementation
String getRegionName()
Get the cache region name
boolean insert(Object key, Object value, Object currentVersion)
Do nothing.
synchronized SoftLock lock(Object key, Object version)
Stop any other transactions reading or writing this item to/from the cache.
synchronized 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.
synchronized void release(Object key, SoftLock clientLock)
Release the soft lock on the item.
void remove(Object key)
Evict an item from the cache immediately (without regard for transaction isolation).
void setCache(Cache cache)
Set the underlying cache implementation.
String toString()
boolean update(Object key, Object value, Object currentVersion, Object previousVersion)
Do nothing.
[Expand]
Inherited Methods
From class java.lang.Object
From interface org.hibernate.cache.CacheConcurrencyStrategy

Public Constructors

public ReadWriteCache ()

Public Methods

public synchronized boolean afterInsert (Object key, Object value, Object version)

Add the new item to the cache, checking that no other transaction has accessed the item.

Throws
CacheException

public synchronized 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. Release our lock.

Throws
CacheException

public void clear ()

Evict all items from the cache immediately.

Throws
CacheException

public void destroy ()

Clean up all resources.

public void evict (Object key)

Do nothing.

Throws
CacheException

public synchronized Object get (Object key, long txTimestamp)

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.

Parameters
txTimestamp a timestamp prior to the transaction start time
Returns
  • the cached object or null
Throws
CacheException

public Cache getCache ()

Get the wrapped cache implementation

public String getRegionName ()

Get the cache region name

public boolean insert (Object key, Object value, Object currentVersion)

Do nothing.

public synchronized SoftLock lock (Object key, Object version)

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.

Throws
CacheException

public synchronized 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. (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.

Parameters
txTimestamp a timestamp prior to the transaction start time
version the item version number
versionComparator a comparator used to compare version numbers
minimalPut indicates that the cache should avoid a put is the item is already cached
Returns
  • true if the object was successfully cached
Throws
CacheException

public synchronized void release (Object key, SoftLock clientLock)

Release the soft lock on the item. Other transactions may now re-cache the item (assuming that no other transaction holds a simultaneous lock).

Throws
CacheException

public void remove (Object key)

Evict an item from the cache immediately (without regard for transaction isolation).

Throws
CacheException

public void setCache (Cache cache)

Set the underlying cache implementation.

public String toString ()

public boolean update (Object key, Object value, Object currentVersion, Object previousVersion)

Do nothing.