Package org.codehaus.groovy.runtime.memoize

## Class ConcurrentCommonCache<K,​V>

- java.lang.Object
- - org.codehaus.groovy.runtime.memoize.ConcurrentCommonCache<K,​V>

- Type Parameters:
    `K` - type of the keys
    `V` - type of the values
  All Implemented Interfaces:
    `java.io.Serializable`, `java.util.Map<K,​V>`, `EvictableCache<K,​V>`, `MemoizeCache<K,​V>`, `ValueConvertable<V,​java.lang.Object>`
  Direct Known Subclasses:
    `ConcurrentSoftCache`

      @ThreadSafe
      public class ConcurrentCommonCache<K,​V>
      extends java.lang.Object
      implements EvictableCache<K,​V>, ValueConvertable<V,​java.lang.Object>, java.io.Serializable

  Represents a simple key-value cache, which is thread safe and backed by a `Map` instance
  Since:
    2.5.0
  See Also:
    Serialized Form

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class | Description
    --- | --- | ---
    `static interface` | `ConcurrentCommonCache.Action<K,​V,​R>` |

    - ### Nested classes/interfaces inherited from interface org.codehaus.groovy.runtime.memoize.EvictableCache

      `EvictableCache.EvictionStrategy`

    - ### Nested classes/interfaces inherited from interface java.util.Map

      `java.util.Map.Entry<K extends java.lang.Object,​V extends java.lang.Object>`

    - ### Nested classes/interfaces inherited from interface org.codehaus.groovy.runtime.memoize.MemoizeCache

      `MemoizeCache.ValueProvider<K,​V>`

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `ConcurrentCommonCache()` | Constructs a cache with unlimited size
    `ConcurrentCommonCache​(int maxSize)` | Constructs a LRU cache with the default initial capacity(16)
    `ConcurrentCommonCache​(int initialCapacity, int maxSize)` | Constructs a LRU cache with the specified initial capacity and max size.
    `ConcurrentCommonCache​(int initialCapacity, int maxSize, EvictableCache.EvictionStrategy evictionStrategy)` | Constructs a cache with limited size
    `ConcurrentCommonCache​(java.util.Map<K,​V> map)` | Constructs a cache backed by the specified `Map` instance

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `cleanUpNullReferences()` | Invoked when some of the held SoftReferences have been evicted by the garbage collector and so should be removed from the cache.
    `void` | `clear()` | Clear the cache
    `java.util.Map<K,​V>` | `clearAll()` | Clear the cache
    `boolean` | `containsKey​(java.lang.Object key)` | Determines if the cache contains an entry for the specified key.
    `boolean` | `containsValue​(java.lang.Object value)` |
    `java.lang.Object` | `convertValue​(V value)` | convert the original value to the target value
    `java.util.Set<java.util.Map.Entry<K,​V>>` | `entrySet()` |
    `V` | `get​(java.lang.Object key)` | Gets a value from the cache
    `V` | `getAndPut​(K key, MemoizeCache.ValueProvider<? super K,​? extends V> valueProvider)` | Try to get the value from cache.
    `V` | `getAndPut​(K key, MemoizeCache.ValueProvider<? super K,​? extends V> valueProvider, boolean shouldCache)` |
    `boolean` | `isEmpty()` |
    `java.util.Set<K>` | `keys()` | Get all keys associated to cached values
    `java.util.Set<K>` | `keySet()` |
    `V` | `put​(K key, V value)` | Associates the specified value with the specified key in the cache.
    `void` | `putAll​(java.util.Map<? extends K,​? extends V> m)` |
    `V` | `remove​(java.lang.Object key)` | Remove the cached value by the key
    `int` | `size()` | Get the size of the cache
    `java.util.Collection<V>` | `values()` | Get all cached values

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface java.util.Map

      `compute, computeIfAbsent, computeIfPresent, equals, forEach, getOrDefault, hashCode, merge, putIfAbsent, remove, replace, replace, replaceAll`

- - ### Constructor Detail

    - #### ConcurrentCommonCache

          public ConcurrentCommonCache()

      Constructs a cache with unlimited size

    - #### ConcurrentCommonCache

          public ConcurrentCommonCache​(int initialCapacity,
                                       int maxSize,
                                       EvictableCache.EvictionStrategy evictionStrategy)

      Constructs a cache with limited size
      Parameters:
        `initialCapacity` - initial capacity of the cache
        `maxSize` - max size of the cache
        `evictionStrategy` - LRU or FIFO, see `EvictableCache.EvictionStrategy`

    - #### ConcurrentCommonCache

          public ConcurrentCommonCache​(int initialCapacity,
                                       int maxSize)

      Constructs a LRU cache with the specified initial capacity and max size. The LRU cache is slower than `LRUCache`
      Parameters:
        `initialCapacity` - initial capacity of the LRU cache
        `maxSize` - max size of the LRU cache

    - #### ConcurrentCommonCache

          public ConcurrentCommonCache​(int maxSize)

      Constructs a LRU cache with the default initial capacity(16)
      Parameters:
        `maxSize` - max size of the LRU cache
      See Also:
        `ConcurrentCommonCache(int, int)`

    - #### ConcurrentCommonCache

          public ConcurrentCommonCache​(java.util.Map<K,​V> map)

      Constructs a cache backed by the specified `Map` instance
      Parameters:
        `map` - the `Map` instance

  - ### Method Detail

    - #### get

          public V get​(java.lang.Object key)

      Gets a value from the cache
      Specified by:
        `get` in interface `java.util.Map<K,​V>`
      Specified by:
        `get` in interface `MemoizeCache<K,​V>`
      Parameters:
        `key` - the key whose associated value is to be returned
      Returns:
        the value, or null, if it does not exist.

    - #### put

          public V put​(K key,
                       V value)

      Associates the specified value with the specified key in the cache.
      Specified by:
        `put` in interface `java.util.Map<K,​V>`
      Specified by:
        `put` in interface `MemoizeCache<K,​V>`
      Parameters:
        `key` - key with which the specified value is to be associated
        `value` - value to be associated with the specified key
      Returns:
        null, or the old value if the key associated with the specified key.

    - #### getAndPut

          public V getAndPut​(K key,
                             MemoizeCache.ValueProvider<? super K,​? extends V> valueProvider)

      Try to get the value from cache. If not found, create the value by `MemoizeCache.ValueProvider` and put it into the cache, at last return the value
      Specified by:
        `getAndPut` in interface `MemoizeCache<K,​V>`
      Returns:
        the cached value

    - #### getAndPut

          public V getAndPut​(K key,
                             MemoizeCache.ValueProvider<? super K,​? extends V> valueProvider,
                             boolean shouldCache)

    - #### values

          public java.util.Collection<V> values()

      Get all cached values
      Specified by:
        `values` in interface `EvictableCache<K,​V>`
      Specified by:
        `values` in interface `java.util.Map<K,​V>`
      Returns:
        all cached values

    - #### entrySet

          public java.util.Set<java.util.Map.Entry<K,​V>> entrySet()

      Specified by:
        `entrySet` in interface `java.util.Map<K,​V>`

    - #### keys

          public java.util.Set<K> keys()

      Get all keys associated to cached values
      Specified by:
        `keys` in interface `EvictableCache<K,​V>`
      Returns:
        all keys

    - #### containsKey

          public boolean containsKey​(java.lang.Object key)

      Determines if the cache contains an entry for the specified key.
      Specified by:
        `containsKey` in interface `EvictableCache<K,​V>`
      Specified by:
        `containsKey` in interface `java.util.Map<K,​V>`
      Parameters:
        `key` - key whose presence in this cache is to be tested.
      Returns:
        true if the cache contains a mapping for the specified key

    - #### containsValue

          public boolean containsValue​(java.lang.Object value)

      Specified by:
        `containsValue` in interface `java.util.Map<K,​V>`

    - #### size

          public int size()

      Get the size of the cache
      Specified by:
        `size` in interface `EvictableCache<K,​V>`
      Specified by:
        `size` in interface `java.util.Map<K,​V>`
      Returns:
        the size of the cache

    - #### isEmpty

          public boolean isEmpty()

      Specified by:
        `isEmpty` in interface `java.util.Map<K,​V>`

    - #### remove

          public V remove​(java.lang.Object key)

      Remove the cached value by the key
      Specified by:
        `remove` in interface `EvictableCache<K,​V>`
      Specified by:
        `remove` in interface `java.util.Map<K,​V>`
      Parameters:
        `key` - of the cached value
      Returns:
        returns the removed value

    - #### putAll

          public void putAll​(java.util.Map<? extends K,​? extends V> m)

      Specified by:
        `putAll` in interface `java.util.Map<K,​V>`

    - #### keySet

          public java.util.Set<K> keySet()

      Specified by:
        `keySet` in interface `java.util.Map<K,​V>`

    - #### clearAll

          public java.util.Map<K,​V> clearAll()

      Clear the cache
      Specified by:
        `clearAll` in interface `EvictableCache<K,​V>`
      Returns:
        returns the content of the cleared map

    - #### clear

          public void clear()

      Clear the cache
      Specified by:
        `clear` in interface `java.util.Map<K,​V>`
      See Also:
        `clearAll()`

    - #### cleanUpNullReferences

          public void cleanUpNullReferences()

      Invoked when some of the held SoftReferences have been evicted by the garbage collector and so should be removed from the cache. The implementation must ensure that concurrent invocations of all methods on the cache may occur from other threads and thus should protect any shared resources.
      Specified by:
        `cleanUpNullReferences` in interface `MemoizeCache<K,​V>`

    - #### convertValue

          public java.lang.Object convertValue​(V value)

      convert the original value to the target value
      Specified by:
        `convertValue` in interface `ValueConvertable<K,​V>`
      Parameters:
        `value` - the original value
      Returns:
        the converted value