Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.opensymphony.xwork2.inject.util
Class ReferenceMap<K,V>

    java.lang.Object
      com.opensymphony.xwork2.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
`protected static interface` | `ReferenceMap.Strategy`

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

Method Summary
`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 com.opensymphony.xwork2.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
`equals, hashCode`

Constructor Detail

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

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

### remove

    public boolean remove(Object key,
                          Object value)

### replace

    public boolean replace(K key,
                           V oldValue,
                           V newValue)

### replace

    public V replace(K key,
                     V value)

### 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 com.opensymphony.xwork2.inject.util.ReferenceMap.PutStrategy getPutStrategy()

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2000–2018 Apache Software Foundation. All rights reserved.