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

Fields
`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

Constructors
Constructor and Description
`ConcurrencyThrottleSupport()`

### Method Summary

Methods
`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()`