Package ca.spottedleaf.concurrentutil.map.concurrent.objects

Class ConcurrentChainedObject2IntHashTable<K>

java.lang.Object
ca.spottedleaf.concurrentutil.map.concurrent.objects.ConcurrentChainedObject2IntHashTable<K>
Type Parameters:
K - The type for keys in this map
All Implemented Interfaces:
Iterable<ConcurrentChainedObject2IntHashTable.TableEntry<K>>
public class ConcurrentChainedObject2IntHashTable<K> extends Object implements Iterable<ConcurrentChainedObject2IntHashTable.TableEntry<K>>
Concurrent hashtable implementation supporting mapping arbitrary non-null K values onto non-null int 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

    • ConcurrentChainedObject2IntHashTable

      public ConcurrentChainedObject2IntHashTable()

    • ConcurrentChainedObject2IntHashTable

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

    • createWithCapacity

      public static <K> ConcurrentChainedObject2IntHashTable<K> createWithCapacity(int capacity, float loadFactor)

    • createWithExpected

      public static <K> ConcurrentChainedObject2IntHashTable<K> createWithExpected(int expected)

    • createWithExpected

      public static <K> ConcurrentChainedObject2IntHashTable<K> createWithExpected(int expected, float loadFactor)

    • getHash

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

    • getLoadFactor

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

    • getAtIndexAcquire

      protected static <K> ConcurrentChainedObject2IntHashTable.TableEntry<K> getAtIndexAcquire(ConcurrentChainedObject2IntHashTable.TableEntry<K>[] table, int index)

    • setAtIndexRelease

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

    • setAtIndexVolatile

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

    • compareAndExchangeAtIndexVolatile

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

    • fetchNewTable

      protected ConcurrentChainedObject2IntHashTable.TableEntry<K>[] fetchNewTable(ConcurrentChainedObject2IntHashTable.TableEntry<K>[] expectedCurr)

    • getNode

      protected final ConcurrentChainedObject2IntHashTable.TableEntry<K> getNode(K key)
      Returns the possible node associated with the key, or null if there is no such node.

    • get

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

    • getOrDefault

      public int getOrDefault(K key, int 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(K 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(int 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(K key, int 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 int put(K key, int 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 ((int)0) if none.
      Throws:
      NullPointerException - If key is null
      NullPointerException - If value is null

    • putIfAbsent

      public int putIfAbsent(K key, int 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 ((int)0) if none and value was associated.
      Throws:
      NullPointerException - If key is null
      NullPointerException - If value is null

    • replace

      public int replace(K key, int 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 ((int)0) if none.
      Throws:
      NullPointerException - If key is null
      NullPointerException - If value is null

    • replace

      public int replace(K key, int expect, int 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 ((int)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 int remove(K 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 ((int)0).
      Parameters:
      key - Specified key
      Returns:
      Old value previously associated with key, or ((int)0) if none.
      Throws:
      NullPointerException - If key is null

    • remove

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

    • removeIf

      public int removeIf(K key, ConcurrentChainedObject2IntHashTable.RemoveIfPredicate<K> 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 ((int)0).

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

      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 int addTo(K key, int increment, int 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 int decFrom(K key, int decrement, int 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<ConcurrentChainedObject2IntHashTable.TableEntry<K>> 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<ConcurrentChainedObject2IntHashTable.TableEntry<K>> iterator()
      Specified by:
      iterator in interface Iterable<K>

    • keyIterator

      public BaseObjectIterator<K> 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 BaseIntIterator 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.

    • keys

      public Set<K> keys()

    • entrySet

      public Set<ConcurrentChainedObject2IntHashTable.TableEntry<K>> entrySet()