Class ConcurrentReferenceHashMap.Segment<K,V>

java.lang.Object
java.util.concurrent.locks.ReentrantLock
org.jboss.logmanager.ConcurrentReferenceHashMap.Segment<K,V>
All Implemented Interfaces:
Serializable, Lock
Enclosing class:
ConcurrentReferenceHashMap<K,V>
static final class ConcurrentReferenceHashMap.Segment<K,V> extends ReentrantLock implements Serializable
Segments are specialized versions of hash tables. This subclasses from ReentrantLock opportunistically, just to simplify some locking and avoid separate construction.

  • Field Details

    • serialVersionUID

      private static final long serialVersionUID
      See Also:

    • count

      transient volatile int count
      The number of elements in this segment's region.

    • modCount

      transient int modCount
      Number of updates that alter the size of the table. This is used during bulk-read methods to make sure they see a consistent snapshot: If modCounts change during a traversal of segments computing size or checking containsValue, then we might have an inconsistent view of state so (usually) must retry.

    • threshold

      transient int threshold
      The table is rehashed when its size exceeds this threshold. (The value of this field is always (int)(capacity * loadFactor).)

    • table

      transient volatile ConcurrentReferenceHashMap.HashEntry<K,V>[] table
      The per-segment table.

    • loadFactor

      final float loadFactor
      The load factor for the hash table. Even though this value is same for all segments, it is replicated to avoid needing links to outer object.

    • refQueue

      transient volatile ReferenceQueue<Object> refQueue
      The collected weak-key reference queue for this segment. This should be (re)initialized whenever table is assigned,

    • keyType

      final ConcurrentReferenceHashMap.ReferenceType keyType

    • valueType

      final ConcurrentReferenceHashMap.ReferenceType valueType

    • identityComparisons

      final boolean identityComparisons

  • Constructor Details

  • Method Details

    • newArray

      static final <K,V> ConcurrentReferenceHashMap.Segment<K,V>[] newArray(int i)

    • keyEq

      private boolean keyEq(Object src, Object dest)

    • setTable

      void setTable(ConcurrentReferenceHashMap.HashEntry<K,V>[] newTable)
      Sets table to new HashEntry array. Call only while holding lock or in constructor.

    • getFirst

      ConcurrentReferenceHashMap.HashEntry<K,V> getFirst(int hash)
      Returns properly casted first entry of bin for given hash.

    • newHashEntry

      ConcurrentReferenceHashMap.HashEntry<K,V> newHashEntry(K key, int hash, ConcurrentReferenceHashMap.HashEntry<K,V> next, V value)

    • readValueUnderLock

      V readValueUnderLock(ConcurrentReferenceHashMap.HashEntry<K,V> e)
      Reads value field of an entry under lock. Called if value field ever appears to be null. This is possible only if a compiler happens to reorder a HashEntry initialization with its table assignment, which is legal under memory model but is not known to ever occur.

    • get

      V get(Object key, int hash)

    • containsKey

      boolean containsKey(Object key, int hash)

    • containsValue

      boolean containsValue(Object value)

    • replace

      boolean replace(K key, int hash, V oldValue, V newValue)

    • replace

      V replace(K key, int hash, V newValue)

    • put

      V put(K key, int hash, V value, boolean onlyIfAbsent)

    • rehash

      int rehash()

    • remove

      V remove(Object key, int hash, Object value, boolean refRemove)
      Remove; match on key only if value null, else match both.

    • removeStale

      final void removeStale()

    • clear

      void clear()