org.springframework.util

## Class ConcurrentReferenceHashMap.Segment

- java.lang.Object
- - java.util.concurrent.locks.ReentrantLock
  - - org.springframework.util.ConcurrentReferenceHashMap.Segment

- All Implemented Interfaces:
    Serializable, Lock
  Enclosing class:
    ConcurrentReferenceHashMap<K,V>

      protected final class ConcurrentReferenceHashMap.Segment
      extends ReentrantLock

  A single segment used to divide the map to allow better concurrent performance.
  See Also:
    Serialized Form

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `Segment(int initialCapacity)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `clear()` Clear all items from this segment.
    `<T> T` | `doTask(int hash, Object key, org.springframework.util.ConcurrentReferenceHashMap.Task<T> task)` Apply an update operation to this segment.
    `int` | `getCount()`
    `ConcurrentReferenceHashMap.Reference<K,V>` | `getReference(Object key, int hash, ConcurrentReferenceHashMap.Restructure restructure)`
    `int` | `getSize()`
    `protected void` | `restructureIfNecessary(boolean allowResize)` Restructure the underlying data structure when it becomes necessary.

    - ### Methods inherited from class java.util.concurrent.locks.ReentrantLock

      `getHoldCount, getOwner, getQueuedThreads, getQueueLength, getWaitingThreads, getWaitQueueLength, hasQueuedThread, hasQueuedThreads, hasWaiters, isFair, isHeldByCurrentThread, isLocked, lock, lockInterruptibly, newCondition, toString, tryLock, tryLock, unlock`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### Segment

          public Segment(int initialCapacity)

  - ### Method Detail

    - #### getReference

          public ConcurrentReferenceHashMap.Reference<K,V> getReference(Object key,
                                                                        int hash,
                                                                        ConcurrentReferenceHashMap.Restructure restructure)

    - #### doTask

          public <T> T doTask(int hash,
                              Object key,
                              org.springframework.util.ConcurrentReferenceHashMap.Task<T> task)

      Apply an update operation to this segment. The segment will be locked during update.
      Parameters:
        `hash` - the hash of the key
        `key` - the key
        `task` - the update operation
      Returns:
        the result of the operation

    - #### clear

          public void clear()

      Clear all items from this segment.

    - #### restructureIfNecessary

          protected final void restructureIfNecessary(boolean allowResize)

      Restructure the underlying data structure when it becomes necessary. This method can increase the size of the references table as well as purge any references that have been garbage collected.
      Parameters:
        `allowResize` - if resizing is permitted

    - #### getSize

          public final int getSize()

      Returns:
        the size of the current references array

    - #### getCount

          public final int getCount()

      Returns:
        the total number of references in this segment