org.springframework.util

## 类 ConcurrencyThrottleSupport

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

- 所有已实现的接口:
    Serializable

      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.

  从以下版本开始:
    1.2.5
  作者:
    Juergen Hoeller
  另请参阅:
    `setConcurrencyLimit(int)`, `beforeAccess()`, `afterAccess()`, `org.springframework.aop.interceptor.ConcurrencyThrottleInterceptor`, `Serializable`, 序列化表格

- - ### 字段概要

    字段
    限定符和类型 | 字段和说明
    --- | ---
    `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.

  - ### 构造器概要

    构造器
    构造器和说明
    `ConcurrencyThrottleSupport()`

  - ### 方法概要

    所有方法 实例方法 具体方法
    限定符和类型 | 方法和说明
    --- | ---
    `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

    - ### 从类继承的方法 java.lang.Object

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

- - ### 字段详细资料

    - #### UNBOUNDED_CONCURRENCY

          public static final int UNBOUNDED_CONCURRENCY

      Permit any number of concurrent invocations: that is, don't throttle concurrency.
      另请参阅:
        常量字段值

    - #### NO_CONCURRENCY

          public static final int NO_CONCURRENCY

      Switch concurrency 'off': that is, don't allow any concurrent invocations.
      另请参阅:
        常量字段值

    - #### logger

          protected transient Log logger

      Transient to optimize serialization

  - ### 构造器详细资料

    - #### ConcurrencyThrottleSupport

          public ConcurrencyThrottleSupport()

  - ### 方法详细资料

    - #### 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.
      返回:
        `true` if the concurrency limit for this instance is active
      另请参阅:
        `getConcurrencyLimit()`

    - #### beforeAccess

          protected void beforeAccess()

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

      This implementation applies the concurrency throttle.

      另请参阅:
        `afterAccess()`

    - #### afterAccess

          protected void afterAccess()

      To be invoked after the main execution logic of concrete subclasses.
      另请参阅:
        `beforeAccess()`