## org.hibernate.cache
Class ReadWriteCache

    java.lang.Object
      org.hibernate.cache.ReadWriteCache

All Implemented Interfaces:
  CacheConcurrencyStrategy

    public class ReadWriteCache

extends Object
implements CacheConcurrencyStrategy

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:
  `for a faster algorithm`, `CacheConcurrencyStrategy`

Nested Class Summary
`static class` `ReadWriteCache.Item` An item of cached data, timestamped with the time it was cached,.
`static class` `ReadWriteCache.Lock` A soft lock which supports concurrent locking, timestamped with the time it was released
`static interface` `ReadWriteCache.Lockable`

Constructor Summary
`ReadWriteCache()`

Method Summary
`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()` Evict all items from the cache immediately.
`void` `destroy()` Clean up all resources.
`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()` Get the wrapped cache implementation
`String` `getRegionName()` Get the cache region name
`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)` 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.

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

Constructor Detail

### ReadWriteCache

    public ReadWriteCache()

Method Detail

### setCache

    public void setCache(Cache cache)

  Description copied from interface: `CacheConcurrencyStrategy`
  Set the underlying cache implementation.

  Specified by:
    `setCache` in interface `CacheConcurrencyStrategy`

### getCache

    public Cache getCache()

  Description copied from interface: `CacheConcurrencyStrategy`
  Get the wrapped cache implementation

  Specified by:
    `getCache` in interface `CacheConcurrencyStrategy`

### getRegionName

    public String getRegionName()

  Description copied from interface: `CacheConcurrencyStrategy`
  Get the cache region name

  Specified by:
    `getRegionName` in interface `CacheConcurrencyStrategy`

### 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.

  Specified by:
    `get` in interface `CacheConcurrencyStrategy`
    `txTimestamp` - a timestamp prior to the transaction start time
  Returns:
    the cached object or `null`
  Throws:
    `CacheException`

### 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.

  Specified by:
    `lock` in interface `CacheConcurrencyStrategy`
  Throws:
    `CacheException`

### 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.

  Specified by:
    `put` in interface `CacheConcurrencyStrategy`
    `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`

### 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).

  Specified by:
    `release` in interface `CacheConcurrencyStrategy`
  Throws:
    `CacheException`

### clear

    public void clear()
               throws CacheException

  Description copied from interface: `CacheConcurrencyStrategy`
  Evict all items from the cache immediately.

  Specified by:
    `clear` in interface `CacheConcurrencyStrategy`
  Throws:
    `CacheException`

### remove

    public void remove(Object key)
                throws CacheException

  Description copied from interface: `CacheConcurrencyStrategy`
  Evict an item from the cache immediately (without regard for transaction isolation).

  Specified by:
    `remove` in interface `CacheConcurrencyStrategy`
  Throws:
    `CacheException`

### destroy

    public void destroy()

  Description copied from interface: `CacheConcurrencyStrategy`
  Clean up all resources.

  Specified by:
    `destroy` in interface `CacheConcurrencyStrategy`

### afterUpdate

    public boolean afterUpdate(Object key,
                               Object value,
                               Object version,
                               SoftLock clientLock)
                        throws CacheException

  Re-cache the updated state, if and only if there there are no other concurrent soft locks. Release our lock.

  Specified by:
    `afterUpdate` in interface `CacheConcurrencyStrategy`
  Throws:
    `CacheException`

### afterInsert

    public boolean afterInsert(Object key,
                               Object value,
                               Object version)
                        throws CacheException

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

  Specified by:
    `afterInsert` in interface `CacheConcurrencyStrategy`
  Throws:
    `CacheException`

### evict

    public void evict(Object key)
               throws CacheException

  Do nothing.

  Specified by:
    `evict` in interface `CacheConcurrencyStrategy`
  Throws:
    `CacheException`

### insert

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

  Do nothing.

  Specified by:
    `insert` in interface `CacheConcurrencyStrategy`

### update

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

  Do nothing.

  Specified by:
    `update` in interface `CacheConcurrencyStrategy`

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`

Copyright © 2001-2010 Red Hat, Inc. All Rights Reserved.