## org.springframework.util
Class ConcurrencyThrottleSupport

    java.lang.Object
      org.springframework.util.ConcurrencyThrottleSupport

All Implemented Interfaces:
  Serializable

Direct Known Subclasses:
  ConcurrencyThrottleInterceptor

    public abstract class ConcurrencyThrottleSupport

extends Object
implements Serializable

Support class for throttling concurrent access to a specific resource.

Designed for use as a base class, with the subclass invoking the `beforeAccess()` and `afterAccess()` methods at appropriate points of its workflow. Note that `afterAccess` should usually be called in a finally block!

The default concurrency limit of this support class is -1 ("unbounded concurrency"). Subclasses may override this default; check the javadoc of the concrete class that you're using.

Since:
  1.2.5
Author:
  Juergen Hoeller
See Also:
  `setConcurrencyLimit(int)`, `beforeAccess()`, `afterAccess()`, `ConcurrencyThrottleInterceptor`, `Serializable`, Serialized Form

Field Summary
`protected Log` `logger` Transient to optimize serialization
`static int` `NO_CONCURRENCY` Switch concurrency 'off': that is, don't allow any concurrent invocations.
`static int` `UNBOUNDED_CONCURRENCY` Permit any number of concurrent invocations: that is, don't throttle concurrency.

Constructor Summary
`ConcurrencyThrottleSupport()`

Method Summary
`protected void` `afterAccess()` To be invoked after the main execution logic of concrete subclasses.
`protected void` `beforeAccess()` To be invoked before the main execution logic of concrete subclasses.
`int` `getConcurrencyLimit()` Return the maximum number of concurrent access attempts allowed.
`boolean` `isThrottleActive()` Return whether this throttle is currently active.
`void` `setConcurrencyLimit(int concurrencyLimit)` Set the maximum number of concurrent access attempts allowed

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### UNBOUNDED_CONCURRENCY

    public static final int UNBOUNDED_CONCURRENCY

  Permit any number of concurrent invocations: that is, don't throttle concurrency.

  See Also:
    Constant Field Values

### NO_CONCURRENCY

    public static final int NO_CONCURRENCY

  Switch concurrency 'off': that is, don't allow any concurrent invocations.

  See Also:
    Constant Field Values

### logger

    protected transient Log logger

  Transient to optimize serialization

Constructor Detail

### ConcurrencyThrottleSupport

    public ConcurrencyThrottleSupport()

Method Detail

### setConcurrencyLimit

    public void setConcurrencyLimit(int concurrencyLimit)

  Set the maximum number of concurrent access attempts allowed. -1 indicates unbounded concurrency.

  In principle, this limit can be changed at runtime, although it is generally designed as a config time setting.

  NOTE: Do not switch between -1 and any concrete limit at runtime, as this will lead to inconsistent concurrency counts: A limit of -1 effectively turns off concurrency counting completely.

### getConcurrencyLimit

    public int getConcurrencyLimit()

  Return the maximum number of concurrent access attempts allowed.

### isThrottleActive

    public boolean isThrottleActive()

  Return whether this throttle is currently active.

  Returns:
    `true` if the concurrency limit for this instance is active
  See Also:
    `getConcurrencyLimit()`

### beforeAccess

    protected void beforeAccess()

  To be invoked before the main execution logic of concrete subclasses.

  This implementation applies the concurrency throttle.

  See Also:
    `afterAccess()`

### afterAccess

    protected void afterAccess()

  To be invoked after the main execution logic of concrete subclasses.

  See Also:
    `beforeAccess()`

Copyright © 2002-2008 The Spring Framework.