Package ca.spottedleaf.concurrentutil.map.concurrent.longs

Class ConcurrentChainedLong2LongHashTable

java.lang.Object
ca.spottedleaf.concurrentutil.map.concurrent.longs.ConcurrentChainedLong2LongHashTable
All Implemented Interfaces:
Iterable<ConcurrentChainedLong2LongHashTable.TableEntry>
public class ConcurrentChainedLong2LongHashTable extends Object implements Iterable<ConcurrentChainedLong2LongHashTable.TableEntry>
Concurrent hashtable implementation supporting mapping arbitrary non-null long values onto non-null 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. Functional methods will be performed atomically, that is, the input parameter is guaranteed to only be invoked at most once per function call. However, the consequence of this behaviour 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

    • ConcurrentChainedLong2LongHashTable

      public ConcurrentChainedLong2LongHashTable()

    • ConcurrentChainedLong2LongHashTable

      protected ConcurrentChainedLong2LongHashTable(int capacity, float loadFactor)

  • Method Details

    • defaultCapacity

      public static int defaultCapacity()

    • defaultLoadFactor

      public static float defaultLoadFactor()

    • 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 ConcurrentChainedLong2LongHashTable createWithCapacity(int capacity)

    • createWithCapacity

      public static ConcurrentChainedLong2LongHashTable createWithCapacity(int capacity, float loadFactor)

    • createWithExpected

      public static ConcurrentChainedLong2LongHashTable createWithExpected(int expected)

    • createWithExpected

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

    • setAtIndexRelease

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

    • setAtIndexVolatile

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

    • compareAndExchangeAtIndexVolatile

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

    • fetchNewTable

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

    • getNode

      protected final ConcurrentChainedLong2LongHashTable.TableEntry getNode(long key)
      Returns the possible node associated with the key, or null if there is no such node.

    • get

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

    • 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
      Throws:
      NullPointerException - If key is null

    • containsKey

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

    • containsValue

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

    • contains

      public boolean contains(long key, long value)
      Returns whether the specified key is mapped and is mapped to the specified value.
      Parameters:
      key - Specified key
      value - Specified value
      Throws:
      NullPointerException - If key is null
      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 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 ((long)0) if none.
      Throws:
      NullPointerException - If key is null
      NullPointerException - If value is null

    • 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 ((long)0) if none and value was associated.
      Throws:
      NullPointerException - If key is null
      NullPointerException - If value is null

    • 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 ((long)0) if none.
      Throws:
      NullPointerException - If key is null
      NullPointerException - If value is null

    • 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 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 equal to expect, then returns the currently mapped value. If the key is not mapped to any value, then returns ((long)0). If neither of the two cases are true, then returns expect.
      Throws:
      NullPointerException - If key is null
      NullPointerException - If expect is null
      NullPointerException - If update is null

    • 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 ((long)0).
      Parameters:
      key - Specified key
      Returns:
      Old value previously associated with key, or ((long)0) if none.
      Throws:
      NullPointerException - If key is null

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

    • removeIf

      public long removeIf(long key, ConcurrentChainedLong2LongHashTable.RemoveIfPredicate 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 ((long)0).

      This function is a "functional method" as defined by ConcurrentChainedLong2LongHashTable.

      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 key is null
      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
      Throws:
      NullPointerException - If key is null

    • 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
      NullPointerException - If key is null

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

    • keyIterator

      public BaseLongIterator 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 BaseLongIterator 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.

    • entrySet

      public Set<ConcurrentChainedLong2LongHashTable.TableEntry> entrySet()