Package com.google.common.util.concurrent

Class AtomicLongMap<K>

  • All Implemented Interfaces:
    java.io.Serializable
    public final class AtomicLongMap<K>
extends java.lang.Object
implements java.io.Serializable
    A map containing long values that can be atomically updated. While writes to a traditional Map rely on put(K, V), the typical mechanism for writing to this map is addAndGet(K, long), which adds a long to the value currently associated with K. If a key has not yet been associated with a value, its implicit value is zero.

    Most methods in this class treat absent values and zero values identically, as individually documented. Exceptions to this are containsKey(java.lang.Object), size(), isEmpty(), asMap, and toString().

    Instances of this class may be used by multiple threads concurrently. All operations are atomic unless otherwise noted.

    Note: If your values are always positive and less than 2^31, you may wish to use a Multiset such as ConcurrentHashMultiset instead.

    Warning: Unlike Multiset, entries whose values are zero are not automatically removed from the map. Instead they must be removed manually with removeAllZeros().

    Since:
    11.0
    See Also:
    Serialized Form

    • Field Summary

      Fields 
      Modifier and Type Field Description
      private java.util.Map<K,​java.lang.Long> asMap  
      private java.util.concurrent.ConcurrentHashMap<K,​java.lang.Long> map  

    • Constructor Summary

      Constructors 
      Modifier Constructor Description
      private AtomicLongMap​(java.util.concurrent.ConcurrentHashMap<K,​java.lang.Long> map)  

    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      long accumulateAndGet​(K key, long x, java.util.function.LongBinaryOperator accumulatorFunction)
      Updates the value currently associated with key by combining it with x via the specified accumulator function, returning the new value.
      long addAndGet​(K key, long delta)
      Adds delta to the value currently associated with key, and returns the new value.
      java.util.Map<K,​java.lang.Long> asMap()
      Returns a live, read-only view of the map backing this AtomicLongMap.
      void clear()
      Removes all of the mappings from this map.
      boolean containsKey​(java.lang.Object key)
      Returns true if this map contains a mapping for the specified key.
      static <K> AtomicLongMap<K> create()
      Creates an AtomicLongMap.
      static <K> AtomicLongMap<K> create​(java.util.Map<? extends K,​? extends java.lang.Long> m)
      Creates an AtomicLongMap with the same mappings as the specified Map.
      private java.util.Map<K,​java.lang.Long> createAsMap()  
      long decrementAndGet​(K key)
      Decrements by one the value currently associated with key, and returns the new value.
      long get​(K key)
      Returns the value associated with key, or zero if there is no value associated with key.
      long getAndAccumulate​(K key, long x, java.util.function.LongBinaryOperator accumulatorFunction)
      Updates the value currently associated with key by combining it with x via the specified accumulator function, returning the old value.
      long getAndAdd​(K key, long delta)
      Adds delta to the value currently associated with key, and returns the old value.
      long getAndDecrement​(K key)
      Decrements by one the value currently associated with key, and returns the old value.
      long getAndIncrement​(K key)
      Increments by one the value currently associated with key, and returns the old value.
      long getAndUpdate​(K key, java.util.function.LongUnaryOperator updaterFunction)
      Updates the value currently associated with key with the specified function, and returns the old value.
      long incrementAndGet​(K key)
      Increments by one the value currently associated with key, and returns the new value.
      boolean isEmpty()
      Returns true if this map contains no key-value mappings.
      long put​(K key, long newValue)
      Associates newValue with key in this map, and returns the value previously associated with key, or zero if there was no such value.
      void putAll​(java.util.Map<? extends K,​? extends java.lang.Long> m)
      Copies all of the mappings from the specified map to this map.
      (package private) long putIfAbsent​(K key, long newValue)
      If key is not already associated with a value or if key is associated with zero, associate it with newValue.
      long remove​(K key)
      Removes and returns the value associated with key.
      (package private) boolean remove​(K key, long value)
      If (key, value) is currently in the map, this method removes it and returns true; otherwise, this method returns false.
      void removeAllZeros()
      Removes all mappings from this map whose values are zero.
      boolean removeIfZero​(K key)
      Atomically remove key from the map iff its associated value is 0.
      (package private) boolean replace​(K key, long expectedOldValue, long newValue)
      If (key, expectedOldValue) is currently in the map, this method replaces expectedOldValue with newValue and returns true; otherwise, this method returns false.
      int size()
      Returns the number of key-value mappings in this map.
      long sum()
      Returns the sum of all values in this map.
      java.lang.String toString()  
      long updateAndGet​(K key, java.util.function.LongUnaryOperator updaterFunction)
      Updates the value currently associated with key with the specified function, and returns the new value.

      • Methods inherited from class java.lang.Object

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

    • Field Detail

      • map

        private final java.util.concurrent.ConcurrentHashMap<K,​java.lang.Long> map

      • asMap

        private transient java.util.Map<K,​java.lang.Long> asMap

    • Constructor Detail

      • AtomicLongMap

        private AtomicLongMap​(java.util.concurrent.ConcurrentHashMap<K,​java.lang.Long> map)

    • Method Detail

      • create

        public static <K> AtomicLongMap<K> create()
        Creates an AtomicLongMap.

      • create

        public static <K> AtomicLongMap<K> create​(java.util.Map<? extends K,​? extends java.lang.Long> m)
        Creates an AtomicLongMap with the same mappings as the specified Map.

      • get

        public long get​(K key)
        Returns the value associated with key, or zero if there is no value associated with key.

      • incrementAndGet

        public long incrementAndGet​(K key)
        Increments by one the value currently associated with key, and returns the new value.

      • decrementAndGet

        public long decrementAndGet​(K key)
        Decrements by one the value currently associated with key, and returns the new value.

      • addAndGet

        public long addAndGet​(K key,
                      long delta)
        Adds delta to the value currently associated with key, and returns the new value.

      • getAndIncrement

        public long getAndIncrement​(K key)
        Increments by one the value currently associated with key, and returns the old value.

      • getAndDecrement

        public long getAndDecrement​(K key)
        Decrements by one the value currently associated with key, and returns the old value.

      • getAndAdd

        public long getAndAdd​(K key,
                      long delta)
        Adds delta to the value currently associated with key, and returns the old value.

      • updateAndGet

        public long updateAndGet​(K key,
                         java.util.function.LongUnaryOperator updaterFunction)
        Updates the value currently associated with key with the specified function, and returns the new value. If there is not currently a value associated with key, the function is applied to 0L.
        Since:
        21.0

      • getAndUpdate

        public long getAndUpdate​(K key,
                         java.util.function.LongUnaryOperator updaterFunction)
        Updates the value currently associated with key with the specified function, and returns the old value. If there is not currently a value associated with key, the function is applied to 0L.
        Since:
        21.0

      • accumulateAndGet

        public long accumulateAndGet​(K key,
                             long x,
                             java.util.function.LongBinaryOperator accumulatorFunction)
        Updates the value currently associated with key by combining it with x via the specified accumulator function, returning the new value. The previous value associated with key (or zero, if there is none) is passed as the first argument to accumulatorFunction, and x is passed as the second argument.
        Since:
        21.0

      • getAndAccumulate

        public long getAndAccumulate​(K key,
                             long x,
                             java.util.function.LongBinaryOperator accumulatorFunction)
        Updates the value currently associated with key by combining it with x via the specified accumulator function, returning the old value. The previous value associated with key (or zero, if there is none) is passed as the first argument to accumulatorFunction, and x is passed as the second argument.
        Since:
        21.0

      • put

        public long put​(K key,
                long newValue)
        Associates newValue with key in this map, and returns the value previously associated with key, or zero if there was no such value.

      • putAll

        public void putAll​(java.util.Map<? extends K,​? extends java.lang.Long> m)
        Copies all of the mappings from the specified map to this map. The effect of this call is equivalent to that of calling put(k, v) on this map once for each mapping from key k to value v in the specified map. The behavior of this operation is undefined if the specified map is modified while the operation is in progress.

      • remove

        public long remove​(K key)
        Removes and returns the value associated with key. If key is not in the map, this method has no effect and returns zero.

      • remove

        boolean remove​(K key,
               long value)
        If (key, value) is currently in the map, this method removes it and returns true; otherwise, this method returns false.

      • removeIfZero

        public boolean removeIfZero​(K key)
        Atomically remove key from the map iff its associated value is 0.
        Since:
        20.0

      • removeAllZeros

        public void removeAllZeros()
        Removes all mappings from this map whose values are zero.

        This method is not atomic: the map may be visible in intermediate states, where some of the zero values have been removed and others have not.

      • sum

        public long sum()
        Returns the sum of all values in this map.

        This method is not atomic: the sum may or may not include other concurrent operations.

      • asMap

        public java.util.Map<K,​java.lang.Long> asMap()
        Returns a live, read-only view of the map backing this AtomicLongMap.

      • createAsMap

        private java.util.Map<K,​java.lang.Long> createAsMap()

      • containsKey

        public boolean containsKey​(java.lang.Object key)
        Returns true if this map contains a mapping for the specified key.

      • size

        public int size()
        Returns the number of key-value mappings in this map. If the map contains more than Integer.MAX_VALUE elements, returns Integer.MAX_VALUE.

      • isEmpty

        public boolean isEmpty()
        Returns true if this map contains no key-value mappings.

      • clear

        public void clear()
        Removes all of the mappings from this map. The map will be empty after this call returns.

        This method is not atomic: the map may not be empty after returning if there were concurrent writes.

      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object

      • putIfAbsent

        long putIfAbsent​(K key,
                 long newValue)
        If key is not already associated with a value or if key is associated with zero, associate it with newValue. Returns the previous value associated with key, or zero if there was no mapping for key.

      • replace

        boolean replace​(K key,
                long expectedOldValue,
                long newValue)
        If (key, expectedOldValue) is currently in the map, this method replaces expectedOldValue with newValue and returns true; otherwise, this method returns false.

        If expectedOldValue is zero, this method will succeed if (key, zero) is currently in the map, or if key is not in the map at all.