Package org.apache.struts2.inject.util

# Class ReferenceMap<K,V>

java.lang.Object
org.apache.struts2.inject.util.ReferenceMap<K,V>

All Implemented Interfaces:
  `Serializable`, `Map<K,V>`

Direct Known Subclasses:
  `ReferenceCache`

public class ReferenceMap<K,V> extends Object implements Map<K,V>, Serializable
Concurrent hash map that wraps keys and/or values in soft or weak references. Does not support null keys or values. Uses identity equality for weak and soft keys.

The concurrent semantics of `ConcurrentHashMap` combined with the fact that the garbage collector can asynchronously reclaim and clean up after keys and values at any time can lead to some racy semantics. For example, `size()` returns an upper bound on the size, i.e. the actual size may be smaller in cases where the key or value has been reclaimed but the map entry has not been cleaned up yet.

Another example: If `get(Object)` cannot find an existing entry for a key, it will try to create one. This operation is not atomic. One thread could `put(Object, Object)` a value between the time another thread running `get()` checks for an entry and decides to create one. In this case, the newly created value will replace the put value in the map. Also, two threads running `get()` concurrently can potentially create duplicate values for a given key.

In other words, this class is great for caching but not atomicity.

Author:
  crazybob@google.com (Bob Lee)
See Also:
  - Serialized Form

- ## Nested Class Summary

  Nested Classes
  Modifier and Type
  Class
  Description
  `protected static interface`
  `ReferenceMap.Strategy`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `ReferenceMap(ReferenceType keyReferenceType, ReferenceType valueReferenceType)`
  Concurrent hash map that wraps keys and/or values based on specified reference types.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `clear()`
  `boolean`
  `containsKey(Object key)`
  `boolean`
  `containsValue(Object value)`
  `Set<Map.Entry<K,V>>`
  `entrySet()`
  Returns an unmodifiable set view of the entries in this map.
  `V`
  `get(Object key)`
  `protected org.apache.struts2.inject.util.ReferenceMap.PutStrategy`
  `getPutStrategy()`
  `boolean`
  `isEmpty()`
  `Set<K>`
  `keySet()`
  Returns an unmodifiable set view of the keys in this map.
  `V`
  `put(K key, V value)`
  `void`
  `putAll(Map<? extends K,? extends V> t)`
  `V`
  `putIfAbsent(K key, V value)`
  `protected ReferenceMap.Strategy`
  `putIfAbsentStrategy()`
  `protected ReferenceMap.Strategy`
  `putStrategy()`
  `V`
  `remove(Object key)`
  `boolean`
  `remove(Object key, Object value)`
  `V`
  `replace(K key, V value)`
  `boolean`
  `replace(K key, V oldValue, V newValue)`
  `protected ReferenceMap.Strategy`
  `replaceStrategy()`
  `int`
  `size()`
  `Collection<V>`
  `values()`
  Returns an unmodifiable set view of the values in this map.

  ### 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, replaceAll`

- ## Constructor Details

  - ### ReferenceMap

    public ReferenceMap(ReferenceType keyReferenceType, ReferenceType valueReferenceType)
    Concurrent hash map that wraps keys and/or values based on specified reference types.
    Parameters:
      `keyReferenceType` - key reference type
      `valueReferenceType` - value reference type

- ## Method Details

  - ### get

    public V get(Object key)
    Specified by:
      `get` in interface `Map<K,V>`

  - ### put

    public V put(K key, V value)
    Specified by:
      `put` in interface `Map<K,V>`

  - ### remove

    public V remove(Object key)
    Specified by:
      `remove` in interface `Map<K,V>`

  - ### size

    public int size()
    Specified by:
      `size` in interface `Map<K,V>`

  - ### isEmpty

    public boolean isEmpty()
    Specified by:
      `isEmpty` in interface `Map<K,V>`

  - ### containsKey

    public boolean containsKey(Object key)
    Specified by:
      `containsKey` in interface `Map<K,V>`

  - ### containsValue

    public boolean containsValue(Object value)
    Specified by:
      `containsValue` in interface `Map<K,V>`

  - ### putAll

    public void putAll(Map<? extends K,? extends V> t)
    Specified by:
      `putAll` in interface `Map<K,V>`

  - ### clear

    public void clear()
    Specified by:
      `clear` in interface `Map<K,V>`

  - ### keySet

    public Set<K> keySet()
    Returns an unmodifiable set view of the keys in this map. As this method creates a defensive copy, the performance is O(n).
    Specified by:
      `keySet` in interface `Map<K,V>`

  - ### values

    public Collection<V> values()
    Returns an unmodifiable set view of the values in this map. As this method creates a defensive copy, the performance is O(n).
    Specified by:
      `values` in interface `Map<K,V>`

  - ### putIfAbsent

    public V putIfAbsent(K key, V value)
    Specified by:
      `putIfAbsent` in interface `Map<K,V>`

  - ### remove

    public boolean remove(Object key, Object value)
    Specified by:
      `remove` in interface `Map<K,V>`

  - ### replace

    public boolean replace(K key, V oldValue, V newValue)
    Specified by:
      `replace` in interface `Map<K,V>`

  - ### replace

    public V replace(K key, V value)
    Specified by:
      `replace` in interface `Map<K,V>`

  - ### entrySet

    public Set<Map.Entry<K,V>> entrySet()
    Returns an unmodifiable set view of the entries in this map. As this method creates a defensive copy, the performance is O(n).
    Specified by:
      `entrySet` in interface `Map<K,V>`

  - ### putStrategy

    protected ReferenceMap.Strategy putStrategy()

  - ### putIfAbsentStrategy

    protected ReferenceMap.Strategy putIfAbsentStrategy()

  - ### replaceStrategy

    protected ReferenceMap.Strategy replaceStrategy()

  - ### getPutStrategy

    protected org.apache.struts2.inject.util.ReferenceMap.PutStrategy getPutStrategy()