Class LimitLatch

java.lang.Object
org.apache.tomcat.util.threads.LimitLatch
public class LimitLatch extends Object
Shared latch that allows the latch to be acquired a limited number of times after which all subsequent requests to acquire the latch will be placed in a FIFO queue until one of the shares is returned.

  • Constructor Summary

    Constructors
    Constructor
    Description
    LimitLatch(long limit)
    Instantiates a LimitLatch object with an initial limit.

  • Method Summary

    Modifier and Type
    Method
    Description
    long
    countDown()
    Releases a shared latch, making it available for another thread to use.
    void
    countUpOrAwait()
    Acquires a shared latch if one is available or waits for one if no shared latch is currently available.
    long
    getCount()
    Returns the current count for the latch
    long
    getLimit()
    Obtain the current limit.
    Collection<Thread>
    getQueuedThreads()
    Provide access to the list of threads waiting to acquire this limited shared latch.
    boolean
    hasQueuedThreads()
    Returns true if there is at least one thread waiting to acquire the shared lock, otherwise returns false.
    boolean
    releaseAll()
    Releases all waiting threads and causes the limit to be ignored until reset() is called.
    void
    reset()
    Resets the latch and initializes the shared acquisition counter to zero.
    void
    setLimit(long limit)
    Sets a new limit.

    Methods inherited from class Object

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

  • Constructor Details

    • LimitLatch

      public LimitLatch(long limit)
      Instantiates a LimitLatch object with an initial limit.
      Parameters:
      limit - - maximum number of concurrent acquisitions of this latch

  • Method Details

    • getCount

      public long getCount()
      Returns the current count for the latch
      Returns:
      the current count for latch

    • getLimit

      public long getLimit()
      Obtain the current limit.
      Returns:
      the limit

    • setLimit

      public void setLimit(long limit)
      Sets a new limit. If the limit is decreased there may be a period where more shares of the latch are acquired than the limit. In this case no more shares of the latch will be issued until sufficient shares have been returned to reduce the number of acquired shares of the latch to below the new limit. If the limit is increased, threads currently in the queue may not be issued one of the newly available shares until the next request is made for a latch.
      Parameters:
      limit - The new limit

    • countUpOrAwait

      public void countUpOrAwait() throws InterruptedException
      Acquires a shared latch if one is available or waits for one if no shared latch is currently available.
      Throws:
      InterruptedException - If the current thread is interrupted

    • countDown

      public long countDown()
      Releases a shared latch, making it available for another thread to use.
      Returns:
      the counter value after the decrement

    • releaseAll

      public boolean releaseAll()
      Releases all waiting threads and causes the limit to be ignored until reset() is called. This method does not change the acquisition counter. Threads that this method releases are counted as holding a share and each must still call countDown() once it has finished, as with any other acquisition.
      Returns:
      true if release was done

    • reset

      public void reset()
      Resets the latch and initializes the shared acquisition counter to zero. Any shares currently held are not accounted for. When the holders of those shares later call countDown(), the counter goes negative which effectively allows that many additional acquisitions before the limit is reached again. Reset the latch only when no shares are held (for example, after using a dedicated latch for a period during which the limit is ignored), or accept that the limit is not reliably enforced until the counter has returned to zero.
      See Also:

    • hasQueuedThreads

      public boolean hasQueuedThreads()
      Returns true if there is at least one thread waiting to acquire the shared lock, otherwise returns false.
      Returns:
      true if threads are waiting

    • getQueuedThreads

      public Collection<Thread> getQueuedThreads()
      Provide access to the list of threads waiting to acquire this limited shared latch.
      Returns:
      a collection of threads