Class ConcurrentReferenceHashMap.Segment<K,​V>

  • All Implemented Interfaces:
    java.io.Serializable, java.util.concurrent.locks.Lock
    Enclosing class:
    ConcurrentReferenceHashMap<K,​V>

    static final class ConcurrentReferenceHashMap.Segment<K,​V>
    extends java.util.concurrent.locks.ReentrantLock
    implements java.io.Serializable
    Segments are specialized versions of hash tables. This subclasses from ReentrantLock opportunistically, just to simplify some locking and avoid separate construction.
    • Field Detail

      • 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).)
      • 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 java.lang.ref.ReferenceQueue<java.lang.Object> refQueue
        The collected weak-key reference queue for this segment. This should be (re)initialized whenever table is assigned,
      • identityComparisons

        final boolean identityComparisons
    • Method Detail

      • keyEq

        private boolean keyEq​(java.lang.Object src,
                              java.lang.Object dest)
      • 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​(java.lang.Object key,
              int hash)
      • containsKey

        boolean containsKey​(java.lang.Object key,
                            int hash)
      • containsValue

        boolean containsValue​(java.lang.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​(java.lang.Object key,
                 int hash,
                 java.lang.Object value,
                 boolean refRemove)
        Remove; match on key only if value null, else match both.
      • removeStale

        final void removeStale()
      • clear

        void clear()