Package ca.spottedleaf.concurrentutil.map

Class ConcurrentLong2LongChainedHashTable

java.lang.Object
ca.spottedleaf.concurrentutil.map.ConcurrentLong2LongChainedHashTable
All Implemented Interfaces:
Iterable<ConcurrentLong2LongChainedHashTable.TableEntry>
public class ConcurrentLong2LongChainedHashTable extends Object implements Iterable<ConcurrentLong2LongChainedHashTable.TableEntry>
Concurrent hashtable implementation supporting mapping arbitrary long values onto long 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, removeIf(long, LongPredicate) is an example of functional a method. 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

    • ConcurrentLong2LongChainedHashTable

      public ConcurrentLong2LongChainedHashTable()

    • ConcurrentLong2LongChainedHashTable

      protected ConcurrentLong2LongChainedHashTable(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 ConcurrentLong2LongChainedHashTable createWithCapacity(int capacity)

    • createWithCapacity

      public static ConcurrentLong2LongChainedHashTable createWithCapacity(int capacity, float loadFactor)

    • createWithExpected

      public static ConcurrentLong2LongChainedHashTable createWithExpected(int expected)

    • createWithExpected

      public static ConcurrentLong2LongChainedHashTable 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 ConcurrentLong2LongChainedHashTable.TableEntry getAtIndexAcquire(ConcurrentLong2LongChainedHashTable.TableEntry[] table, int index)

    • setAtIndexRelease

      protected static void setAtIndexRelease(ConcurrentLong2LongChainedHashTable.TableEntry[] table, int index, ConcurrentLong2LongChainedHashTable.TableEntry value)

    • setAtIndexVolatile

      protected static void setAtIndexVolatile(ConcurrentLong2LongChainedHashTable.TableEntry[] table, int index, ConcurrentLong2LongChainedHashTable.TableEntry value)

    • compareAndExchangeAtIndexVolatile

      protected static ConcurrentLong2LongChainedHashTable.TableEntry compareAndExchangeAtIndexVolatile(ConcurrentLong2LongChainedHashTable.TableEntry[] table, int index, ConcurrentLong2LongChainedHashTable.TableEntry expect, ConcurrentLong2LongChainedHashTable.TableEntry update)

    • fetchNewTable

      protected ConcurrentLong2LongChainedHashTable.TableEntry[] fetchNewTable(ConcurrentLong2LongChainedHashTable.TableEntry[] expectedCurr)

    • getNode

      protected final ConcurrentLong2LongChainedHashTable.TableEntry 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 ConcurrentLong2LongChainedHashTable.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 long get(long key)
      Returns the currently mapped value associated with the specified key, or 0L if there is none.
      Parameters:
      key - Specified key

    • getOrDefault

      public long getOrDefault(long key, long 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(long value)
      Returns whether the specified value has a key mapped to it.
      Parameters:
      value - Specified value

    • 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 long put(long key, long 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 0L if none.

    • putIfAbsent

      public long putIfAbsent(long key, long 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 0L if none and value was associated.

    • replace

      public long replace(long key, long 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 0L if none.

    • replace

      public long replace(long key, long expect, long 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 0L. If neither of the two cases are true, then returns expect.

    • remove

      public long 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 0L.
      Parameters:
      key - Specified key
      Returns:
      Old value previously associated with key, or 0L if none.

    • remove

      public long remove(long key, long 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 0L. If the key is mapped to a value that is not 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 0L. If neither of those cases are true, then returns the current (possibly zero) mapped value for key.

    • removeIf

      public long removeIf(long key, LongPredicate 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 0L.

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

      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 0L. If neither of those cases are true, then returns the current (possibly zero) mapped value for key.
      Throws:
      NullPointerException - If predicate is null

    • addTo

      public long addTo(long key, long increment, long defaultValue)
      Atomically inserts a mapping for the specified key with the provided default value if the key is not mapped or updates the current value by adding the specified increment.
      Parameters:
      key - Specified key
      increment - Specified increment
      defaultValue - Specified default value
      Returns:
      The newly mapped value

    • decFrom

      public long decFrom(long key, long decrement, long threshold)
      Atomically decrements the mapping by the specified decrement and then removes the mapping if it is below or equal to the specified threshold. If the key is not mapped, then an exception is thrown.
      Parameters:
      key - Specified key
      decrement - Specified decrement
      threshold - Specified threshold
      Returns:
      The previous value decremented by the specified decrement
      Throws:
      IllegalStateException - If there exists no mapping for the key

    • 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<ConcurrentLong2LongChainedHashTable.TableEntry> 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<ConcurrentLong2LongChainedHashTable.TableEntry> iterator()
      Specified by:
      iterator in interface Iterable<ConcurrentLong2LongChainedHashTable.TableEntry>

    • 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 PrimitiveIterator.OfLong 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.