com.google.common.collect
Class MapMaker

java.lang.Object
  com.google.common.collect.MapMaker

public final class MapMaker
extends java.lang.Object

A ConcurrentMap builder, providing any combination of these features: soft or weak keys, soft or weak values, timed expiration, and on-demand computation of values. Usage example:

 ConcurrentMap<Key, Graph> graphs = new MapMaker()
       .concurrencyLevel(32)
       .softKeys()
       .weakValues()
       .expiration(30, TimeUnit.MINUTES)
       .makeComputingMap(
           new Function<Key, Graph>() {
             public Graph apply(Key key) {
               return createExpensiveGraph(key);
             }
           });

These features are all optional; new MapMaker().makeMap() returns a valid concurrent map that behaves exactly like a ConcurrentHashMap. The returned map is implemented as a hash table with similar performance characteristics to ConcurrentHashMap. It supports all optional operations of the ConcurrentMap interface. It does not permit null keys or values. It is serializable; however, serializing a map that uses soft or weak references can give unpredictable results.

Note: by default, the returned map uses equality comparisons (the equals method) to determine equality for keys or values. However, if weakKeys() or softKeys() was specified, the map uses identity (==) comparisons instead for keys. Likewise, if weakValues() or softValues() was specified, the map uses identity comparisons for values.

The returned map has weakly consistent iteration: an iterator over one of the map's view collections may reflect some, all or none of the changes made to the map after the iterator was created.

An entry whose key or value is reclaimed by the garbage collector immediately disappears from the map. (If the default settings of strong keys and strong values are used, this will never happen.) The client can never observe a partially-reclaimed entry. Any Map.Entry instance retrieved from the map's entry set is snapshot of that entry's state at the time of retrieval.

new MapMaker().weakKeys().makeMap() can almost always be used as a drop-in replacement for WeakHashMap, adding concurrency, asynchronous cleanup, identity-based equality for keys, and great flexibility.

Author:

Bob Lee, Kevin Bourrillion

Constructor Summary

MapMaker()
Constructs a new MapMaker instance with default settings, including strong keys, strong values, and no automatic expiration.

Method Summary

MapMaker	concurrencyLevel(int concurrencyLevel) C Guides the allowed concurrency among update operations.
MapMaker	expiration(long duration, java.util.concurrent.TimeUnit unit) Specifies that each entry should be automatically removed from the map once a fixed duration has passed since the entry's creation.
MapMaker	initialCapacity(int initialCapacity) Sets a custom initial capacity (defaults to 16).
MapMaker	loadFactor(float loadFactor) Sets a custom load factor (defaults to 0.75).
<K,V> java.util.concurrent.ConcurrentMap<K,V>	makeComputingMap(Function<? super K,? extends V> computer) See CustomConcurrentHashMap.Builder.buildComputingMap( CustomConcurrentHashMap.ComputingStrategy, com.google.common.base.Function).
<K,V> java.util.concurrent.ConcurrentMap<K,V>	makeMap() Builds the final map, without on-demand computation of values.
MapMaker	softKeys() Specifies that each key (not value) stored in the map should be wrapped in a SoftReference (by default, strong references are used).
MapMaker	softValues() Specifies that each value (not key) stored in the map should be wrapped in a SoftReference (by default, strong references are used).
MapMaker	weakKeys() Specifies that each key (not value) stored in the map should be wrapped in a WeakReference (by default, strong references are used).
MapMaker	weakValues() Specifies that each value (not key) stored in the map should be wrapped in a WeakReference (by default, strong references are used).

Methods inherited from class java.lang.Object

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

Constructor Detail

MapMaker

public MapMaker()

Constructs a new MapMaker instance with default settings, including strong keys, strong values, and no automatic expiration.

Method Detail

initialCapacity

public MapMaker initialCapacity(int initialCapacity)

Sets a custom initial capacity (defaults to 16). Resizing this or any other kind of hash table is a relatively slow operation, so, when possible, it is a good idea to provide estimates of expected table sizes.

Throws:

java.lang.IllegalArgumentException - if initialCapacity is negative

java.lang.IllegalStateException - if an initial capacity was already set (TODO: make that true)

loadFactor

public MapMaker loadFactor(float loadFactor)

Sets a custom load factor (defaults to 0.75).

Throws:

java.lang.IllegalArgumentException - if loadFactor is nonpositive

java.lang.IllegalStateException - if a load factor was already set (TODO: make that true)

concurrencyLevel

public MapMaker concurrencyLevel(int concurrencyLevel)

C Guides the allowed concurrency among update operations. Used as a hint for internal sizing. The table is internally partitioned to try to permit the indicated number of concurrent updates without contention. Because placement in hash tables is essentially random, the actual concurrency will vary. Ideally, you should choose a value to accommodate as many threads as will ever concurrently modify the table. Using a significantly higher value than you need can waste space and time, and a significantly lower value can lead to thread contention. But overestimates and underestimates within an order of magnitude do not usually have much noticeable impact. A value of one is appropriate when it is known that only one thread will modify and all others will only read. Defaults to 16.

Throws:

java.lang.IllegalArgumentException - if concurrencyLevel is nonpositive

java.lang.IllegalStateException - if a concurrency level was already set (TODO: make that true)

weakKeys

public MapMaker weakKeys()

Specifies that each key (not value) stored in the map should be wrapped in a WeakReference (by default, strong references are used).

Throws:

java.lang.IllegalStateException - if the key strength was already set

softKeys

public MapMaker softKeys()

Specifies that each key (not value) stored in the map should be wrapped in a SoftReference (by default, strong references are used).

Throws:

java.lang.IllegalStateException - if the key strength was already set

weakValues

public MapMaker weakValues()

Specifies that each value (not key) stored in the map should be wrapped in a WeakReference (by default, strong references are used).

Throws:

java.lang.IllegalStateException - if the key strength was already set

softValues

public MapMaker softValues()

Specifies that each value (not key) stored in the map should be wrapped in a SoftReference (by default, strong references are used).

Throws:

java.lang.IllegalStateException - if the value strength was already set

expiration

public MapMaker expiration(long duration,
                           java.util.concurrent.TimeUnit unit)

Specifies that each entry should be automatically removed from the map once a fixed duration has passed since the entry's creation.

Parameters:

duration - the length of time after an entry is created that it should be automatically removed

unit - the unit that duration is expressed in

Throws:

java.lang.IllegalArgumentException - if duration is not positive

java.lang.IllegalStateException - if the expiration time was already set

makeMap

public <K,V> java.util.concurrent.ConcurrentMap<K,V> makeMap()

Builds the final map, without on-demand computation of values.

Type Parameters:

K - the type of keys to be stored in the returned map

V - the type of values to be stored in the returned map

Returns:

a concurrent map having the requested features

makeComputingMap

public <K,V> java.util.concurrent.ConcurrentMap<K,V> makeComputingMap(Function<? super K,? extends V> computer)

See CustomConcurrentHashMap.Builder.buildComputingMap( CustomConcurrentHashMap.ComputingStrategy, com.google.common.base.Function).

If Map.put(K, V) is called before a computation completes, other threads waiting on the computation will wake up and return the put value up until the computation completes, at which point the computation result will overwrite the value from the put in the map.