SemaphoreValve (Apache Tomcat 9.0.111 API Documentation)
Description: declaration: package: org.apache.catalina.valves, class: SemaphoreValve

# Class SemaphoreValve

java.lang.Object
org.apache.catalina.util.LifecycleBase
org.apache.catalina.util.LifecycleMBeanBase
org.apache.catalina.valves.ValveBase
org.apache.catalina.valves.SemaphoreValve

All Implemented Interfaces:
  `MBeanRegistration, Contained, JmxEnabled, Lifecycle, Valve`

public class SemaphoreValve extends ValveBase

Implementation of a Valve that limits concurrency.

This Valve may be attached to any Container, depending on the granularity of the concurrency control you wish to perform. Note that internally, some async requests may require multiple serial requests to complete what - to the user - appears as a single request.

- ## Nested Class Summary

  ### Nested classes/interfaces inherited from interface Lifecycle

  `Lifecycle.SingleUse`

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected boolean`
  `block`
  Block until a permit is available.
  `protected int`
  `concurrency`
  Concurrency level of the semaphore.
  `protected boolean`
  `fairness`
  Fairness of the semaphore.
  `protected int`
  `highConcurrencyStatus`
  High concurrency status.
  `protected boolean`
  `interruptible`
  Block interruptibly until a permit is available.
  `protected Semaphore`
  `semaphore`
  Semaphore.

  ### Fields inherited from class ValveBase

  `asyncSupported, container, containerLog, next, sm`

  ### Fields inherited from class LifecycleMBeanBase

  `mserver`

  ### Fields inherited from interface Lifecycle

  `AFTER_DESTROY_EVENT, AFTER_INIT_EVENT, AFTER_START_EVENT, AFTER_STOP_EVENT, BEFORE_DESTROY_EVENT, BEFORE_INIT_EVENT, BEFORE_START_EVENT, BEFORE_STOP_EVENT, CONFIGURE_START_EVENT, CONFIGURE_STOP_EVENT, PERIODIC_EVENT, START_EVENT, STOP_EVENT`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `SemaphoreValve()`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `boolean`
  `controlConcurrency(Request request, Response response)`
  Subclass friendly method to add conditions.
  `boolean`
  `getBlock()`
  `int`
  `getConcurrency()`
  `boolean`
  `getFairness()`
  `int`
  `getHighConcurrencyStatus()`
  `boolean`
  `getInterruptible()`
  `void`
  `invoke(Request request, Response response)`
  Do concurrency control on the request using the semaphore.
  `void`
  `permitDenied(Request request, Response response)`
  Subclass friendly method to add error handling when a permit isn't granted.
  `void`
  `setBlock(boolean block)`
  `void`
  `setConcurrency(int concurrency)`
  `void`
  `setFairness(boolean fairness)`
  `void`
  `setHighConcurrencyStatus(int highConcurrencyStatus)`
  `void`
  `setInterruptible(boolean interruptible)`
  `protected void`
  `startInternal()`
  Start this component and implement the requirements of `LifecycleBase.startInternal()`.
  `protected void`
  `stopInternal()`
  Stop this component and implement the requirements of `LifecycleBase.stopInternal()`.

  ### Methods inherited from class ValveBase

  `backgroundProcess, getContainer, getDomainInternal, getNext, getObjectNameKeyProperties, initInternal, isAsyncSupported, setAsyncSupported, setContainer, setNext, toString`

  ### Methods inherited from class LifecycleMBeanBase

  `destroyInternal, getDomain, getObjectName, postDeregister, postRegister, preDeregister, preRegister, register, setDomain, unregister, unregister`

  ### Methods inherited from class LifecycleBase

  `addLifecycleListener, destroy, findLifecycleListeners, fireLifecycleEvent, getState, getStateName, getThrowOnFailure, init, removeLifecycleListener, setState, setState, setThrowOnFailure, start, stop`

  ### Methods inherited from class Object

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

- ## Field Details

  - ### semaphore

    protected Semaphore semaphore
    Semaphore.

  - ### concurrency

    protected int concurrency
    Concurrency level of the semaphore.

  - ### fairness

    protected boolean fairness
    Fairness of the semaphore.

  - ### block

    protected boolean block
    Block until a permit is available.

  - ### interruptible

    protected boolean interruptible
    Block interruptibly until a permit is available.

  - ### highConcurrencyStatus

    protected int highConcurrencyStatus
    High concurrency status. This status code is returned as an error if concurrency is too high.

- ## Constructor Details

  - ### SemaphoreValve

    public SemaphoreValve()

- ## Method Details

  - ### getConcurrency

    public int getConcurrency()

  - ### setConcurrency

    public void setConcurrency(int concurrency)

  - ### getFairness

    public boolean getFairness()

  - ### setFairness

    public void setFairness(boolean fairness)

  - ### getBlock

    public boolean getBlock()

  - ### setBlock

    public void setBlock(boolean block)

  - ### getInterruptible

    public boolean getInterruptible()

  - ### setInterruptible

    public void setInterruptible(boolean interruptible)

  - ### getHighConcurrencyStatus

    public int getHighConcurrencyStatus()

  - ### setHighConcurrencyStatus

    public void setHighConcurrencyStatus(int highConcurrencyStatus)

  - ### startInternal

    protected void startInternal() throws LifecycleException
    Start this component and implement the requirements of `LifecycleBase.startInternal()`.
    Overrides:
      `startInternal` in class `ValveBase`
    Throws:
      `LifecycleException` - if this component detects a fatal error that prevents this component from being used

  - ### stopInternal

    protected void stopInternal() throws LifecycleException
    Stop this component and implement the requirements of `LifecycleBase.stopInternal()`.
    Overrides:
      `stopInternal` in class `ValveBase`
    Throws:
      `LifecycleException` - if this component detects a fatal error that prevents this component from being used

  - ### invoke

    public void invoke(Request request, Response response) throws IOException, ServletException
    Do concurrency control on the request using the semaphore.
    Parameters:
      `request` - The servlet request to be processed
      `response` - The servlet response to be created
    Throws:
      `IOException` - if an input/output error occurs
      `ServletException` - if a servlet error occurs

  - ### controlConcurrency

    public boolean controlConcurrency(Request request, Response response)
    Subclass friendly method to add conditions.
    Parameters:
      `request` - The Servlet request
      `response` - The Servlet response
    Returns:
      `true` if the concurrency control should occur on this request

  - ### permitDenied

    public void permitDenied(Request request, Response response) throws IOException, ServletException
    Subclass friendly method to add error handling when a permit isn't granted.
    Parameters:
      `request` - The Servlet request
      `response` - The Servlet response
    Throws:
      `IOException` - Error writing output
      `ServletException` - Other error