Package ca.spottedleaf.concurrentutil.map

Class ConcurrentLong2ReferenceChainedHashTable<V>

java.lang.Object
ca.spottedleaf.concurrentutil.map.ConcurrentLong2ReferenceChainedHashTable<V>
Type Parameters:
V -
All Implemented Interfaces:
Iterable<ConcurrentLong2ReferenceChainedHashTable.TableEntry<V>>
public class ConcurrentLong2ReferenceChainedHashTable<V> extends Object implements Iterable<ConcurrentLong2ReferenceChainedHashTable.TableEntry<V>>
Concurrent hashtable implementation supporting mapping arbitrary long values onto non-null Object values with support for multiple writer and multiple reader threads.

Happens-before relationship

As with ConcurrentMap, there is a happens-before relationship between actions in one thread prior to writing to the map and access to the results of those actions in another thread.

Atomicity of functional methods

Functional methods are functions declared in this class which possibly perform a write (remove, replace, or modify) to an entry in this map as a result of invoking a function on an input parameter. For example, compute(long, BiLong1Function), merge(long, Object, BiFunction) and removeIf(long, Predicate) are examples of functional methods. Functional methods will be performed atomically, that is, the input parameter is guaranteed to only be invoked at most once per function call. The consequence of this behavior however is that a critical lock for a bin entry is held, which means that if the input parameter invocation makes additional calls to write into this hash table that the result is undefined and deadlock-prone.

See Also:

  • Field Details

  • Constructor Details

    • ConcurrentLong2ReferenceChainedHashTable

      public ConcurrentLong2ReferenceChainedHashTable()

    • ConcurrentLong2ReferenceChainedHashTable

      protected ConcurrentLong2ReferenceChainedHashTable(int capacity, float loadFactor)

  • Method Details

    • getThresholdAcquire

      protected final int getThresholdAcquire()

    • getThresholdVolatile

      protected final int getThresholdVolatile()

    • setThresholdPlain

      protected final void setThresholdPlain(int threshold)

    • setThresholdRelease

      protected final void setThresholdRelease(int threshold)

    • setThresholdVolatile

      protected final void setThresholdVolatile(int threshold)

    • compareExchangeThresholdVolatile

      protected final int compareExchangeThresholdVolatile(int expect, int update)

    • getTargetThreshold

      protected static int getTargetThreshold(int capacity, float loadFactor)

    • getCapacityFor

      protected static int getCapacityFor(int capacity)

    • createWithCapacity

      public static <V> ConcurrentLong2ReferenceChainedHashTable<V> createWithCapacity(int capacity)

    • createWithCapacity

      public static <V> ConcurrentLong2ReferenceChainedHashTable<V> createWithCapacity(int capacity, float loadFactor)

    • createWithExpected

      public static <V> ConcurrentLong2ReferenceChainedHashTable<V> createWithExpected(int expected)

    • createWithExpected

      public static <V> ConcurrentLong2ReferenceChainedHashTable<V> createWithExpected(int expected, float loadFactor)

    • getHash

      protected static int getHash(long key)
      must be deterministic given a key

    • getLoadFactor

      public final float getLoadFactor()
      Returns the load factor associated with this map.

    • getAtIndexAcquire

      protected static <V> ConcurrentLong2ReferenceChainedHashTable.TableEntry<V> getAtIndexAcquire(ConcurrentLong2ReferenceChainedHashTable.TableEntry<V>[] table, int index)

    • setAtIndexRelease

      protected static <V> void setAtIndexRelease(ConcurrentLong2ReferenceChainedHashTable.TableEntry<V>[] table, int index, ConcurrentLong2ReferenceChainedHashTable.TableEntry<V> value)

    • setAtIndexVolatile

      protected static <V> void setAtIndexVolatile(ConcurrentLong2ReferenceChainedHashTable.TableEntry<V>[] table, int index, ConcurrentLong2ReferenceChainedHashTable.TableEntry<V> value)

    • compareAndExchangeAtIndexVolatile

      protected static <V> ConcurrentLong2ReferenceChainedHashTable.TableEntry<V> compareAndExchangeAtIndexVolatile(ConcurrentLong2ReferenceChainedHashTable.TableEntry<V>[] table, int index, ConcurrentLong2ReferenceChainedHashTable.TableEntry<V> expect, ConcurrentLong2ReferenceChainedHashTable.TableEntry<V> update)

    • fetchNewTable

      protected ConcurrentLong2ReferenceChainedHashTable.TableEntry<V>[] fetchNewTable(ConcurrentLong2ReferenceChainedHashTable.TableEntry<V>[] expectedCurr)

    • getNode

      protected final ConcurrentLong2ReferenceChainedHashTable.TableEntry<V> getNode(long key)
      Returns the possible node associated with the key, or null if there is no such node. The node returned may have a null ConcurrentLong2ReferenceChainedHashTable.TableEntry.value, in which case the node is a placeholder for a compute/computeIfAbsent call. The placeholder node should not be considered mapped in order to preserve happens-before relationships between writes and reads in the map.

    • get

      public V get(long key)
      Returns the currently mapped value associated with the specified key, or null if there is none.
      Parameters:
      key - Specified key

    • getOrDefault

      public V getOrDefault(long key, V defaultValue)
      Returns the currently mapped value associated with the specified key, or the specified default value if there is none.
      Parameters:
      key - Specified key
      defaultValue - Specified default value

    • containsKey

      public boolean containsKey(long key)
      Returns whether the specified key is mapped to some value.
      Parameters:
      key - Specified key

    • containsValue

      public boolean containsValue(V value)
      Returns whether the specified value has a key mapped to it.
      Parameters:
      value - Specified value
      Throws:
      NullPointerException - If value is null

    • size

      public int size()
      Returns the number of mappings in this map.

    • isEmpty

      public boolean isEmpty()
      Returns whether this map has no mappings.

    • addSize

      protected final void addSize(long count)
      Adds count to size and checks threshold for resizing

    • subSize

      protected final void subSize(long count)
      Subtracts count from size

    • put

      public V put(long key, V value)
      Atomically updates the value associated with key to value, or inserts a new mapping with key mapped to value.
      Parameters:
      key - Specified key
      value - Specified value
      Returns:
      Old value previously associated with key, or null if none.
      Throws:
      NullPointerException - If value is null

    • putIfAbsent

      public V putIfAbsent(long key, V value)
      Atomically inserts a new mapping with key mapped to value if and only if key is not currently mapped to some value.
      Parameters:
      key - Specified key
      value - Specified value
      Returns:
      Value currently associated with key, or null if none and value was associated.
      Throws:
      NullPointerException - If value is null

    • replace

      public V replace(long key, V value)
      Atomically updates the value associated with key to value, or does nothing if key is not associated with a value.
      Parameters:
      key - Specified key
      value - Specified value
      Returns:
      Old value previously associated with key, or null if none.
      Throws:
      NullPointerException - If value is null

    • replace

      public V replace(long key, V expect, V update)
      Atomically updates the value associated with key to update if the currently associated value is reference equal to expect, otherwise does nothing.
      Parameters:
      key - Specified key
      expect - Expected value to check current mapped value with
      update - Update value to replace mapped value with
      Returns:
      If the currently mapped value is not reference equal to expect, then returns the currently mapped value. If the key is not mapped to any value, then returns null. If neither of the two cases are true, then returns expect.
      Throws:
      NullPointerException - If value is null

    • remove

      public V remove(long key)
      Atomically removes the mapping for the specified key and returns the value it was associated with. If the key is not mapped to a value, then does nothing and returns null.
      Parameters:
      key - Specified key
      Returns:
      Old value previously associated with key, or null if none.

    • remove

      public V remove(long key, V expect)
      Atomically removes the mapping for the specified key if it is mapped to expect and returns expect. If the key is not mapped to a value, then does nothing and returns null. If the key is mapped to a value that is not reference equal to expect, then returns that value.
      Parameters:
      key - Specified key
      expect - Specified expected value
      Returns:
      The specified expected value if the key was mapped to expect. If the key is not mapped to any value, then returns null. If neither of those cases are true, then returns the current (non-null) mapped value for key.

    • removeIf

      public V removeIf(long key, Predicate<? super V> predicate)
      Atomically removes the mapping for the specified key the predicate returns true for its currently mapped value. If the key is not mapped to a value, then does nothing and returns null.

      This function is a "functional methods" as defined by ConcurrentLong2ReferenceChainedHashTable.

      Parameters:
      key - Specified key
      predicate - Specified predicate
      Returns:
      The specified expected value if the key was mapped to expect. If the key is not mapped to any value, then returns null. If neither of those cases are true, then returns the current (non-null) mapped value for key.
      Throws:
      NullPointerException - If predicate is null

    • compute

      public V compute(long key, BiLong1Function<? super V,? extends V> function)
      See ConcurrentMap.compute(Object, BiFunction)

      This function is a "functional methods" as defined by ConcurrentLong2ReferenceChainedHashTable.

    • computeIfAbsent

      public V computeIfAbsent(long key, LongFunction<? extends V> function)
      See ConcurrentMap.computeIfAbsent(Object, Function)

      This function is a "functional methods" as defined by ConcurrentLong2ReferenceChainedHashTable.

    • computeIfPresent

      public V computeIfPresent(long key, BiLong1Function<? super V,? extends V> function)
      See ConcurrentMap.computeIfPresent(Object, BiFunction)

      This function is a "functional methods" as defined by ConcurrentLong2ReferenceChainedHashTable.

    • merge

      public V merge(long key, V def, BiFunction<? super V,? super V,? extends V> function)
      See ConcurrentMap.merge(Object, Object, BiFunction)

      This function is a "functional methods" as defined by ConcurrentLong2ReferenceChainedHashTable.

    • clear

      public void clear()
      Removes at least all entries currently mapped at the beginning of this call. May not remove entries added during this call. As a result, only if this map is not modified during the call, that all entries will be removed by the end of the call.

      This function is not atomic.

    • entryIterator

      public Iterator<ConcurrentLong2ReferenceChainedHashTable.TableEntry<V>> entryIterator()
      Returns an iterator over the entries in this map. The iterator is only guaranteed to see entries that were added before the beginning of this call, but it may see entries added during.

    • iterator

      public final Iterator<ConcurrentLong2ReferenceChainedHashTable.TableEntry<V>> iterator()
      Specified by:
      iterator in interface Iterable<V>

    • keyIterator

      public PrimitiveIterator.OfLong keyIterator()
      Returns an iterator over the keys in this map. The iterator is only guaranteed to see keys that were added before the beginning of this call, but it may see keys added during.

    • valueIterator

      public Iterator<V> valueIterator()
      Returns an iterator over the values in this map. The iterator is only guaranteed to see values that were added before the beginning of this call, but it may see values added during.

    • values

      public Collection<V> values()

    • entrySet

      public Set<ConcurrentLong2ReferenceChainedHashTable.TableEntry<V>> entrySet()