Package reactor.pool

Interface AllocationStrategy

All Known Implementing Classes:
SamplingAllocationStrategy
public interface AllocationStrategy
A strategy guiding the Pool on whether or not it is possible to invoke the resource allocator.

See PoolBuilder.sizeBetween(int, int) and PoolBuilder.sizeUnbounded() for pre-made strategies.

Author:
Simon Baslé

  • Method Summary

    Modifier and Type
    Method
    Description
    int
    estimatePermitCount()
    Best-effort peek at the state of the strategy which indicates roughly how many more resources can currently be allocated.
    int
    getPermits(int desired)
    Try to get the permission to allocate a desired positive number of new resources.
    int
    permitGranted()
     
    int
    permitMaximum()
     
    int
    permitMinimum()
    Return the minimum number of permits this strategy tries to maintain granted (reflecting a minimal size for the pool), or 0 for scale-to-zero.
    void
    returnPermits(int returned)
    Update the strategy to indicate that N resources were discarded from the Pool, potentially leaving space for N new ones to be allocated.
    default int
    warmupParallelism()
    Return the concurrency level used when the allocator is subscribed to during the warmup phase, if any.

  • Method Details

    • estimatePermitCount

      int estimatePermitCount()
      Best-effort peek at the state of the strategy which indicates roughly how many more resources can currently be allocated. Should be paired with getPermits(int) for an atomic permission.
      Returns:
      an ESTIMATED count of how many more resources can currently be allocated

    • getPermits

      int getPermits(int desired)
      Try to get the permission to allocate a desired positive number of new resources. Returns the permissible number of resources which MUST be created (otherwise the internal live counter of the strategy might be off). This permissible number might be zero, and it can also be a greater number than desired, which could for example denote a minimum warmed-up size for the pool to maintain (see below). Once a resource is discarded from the pool, it must update the strategy using returnPermits(int) (which can happen in batches or with value 1).

      For the warming up case, the typical pattern would be to call this method with a desired of zero.

      Parameters:
      desired - the desired number of new resources
      Returns:
      the actual number of new resources that MUST be created, can be 0 and can be more than desired

    • permitGranted

      int permitGranted()
      Returns:
      a best estimate of the number of permits currently granted, between 0 and Integer.MAX_VALUE

    • permitMinimum

      int permitMinimum()
      Return the minimum number of permits this strategy tries to maintain granted (reflecting a minimal size for the pool), or 0 for scale-to-zero.
      Returns:
      the minimum number of permits this strategy tries to maintain, or 0

    • permitMaximum

      int permitMaximum()
      Returns:
      the maximum number of permits this strategy can grant in total, or Integer.MAX_VALUE for unbounded

    • returnPermits

      void returnPermits(int returned)
      Update the strategy to indicate that N resources were discarded from the Pool, potentially leaving space for N new ones to be allocated. Users MUST ensure that this method isn't called with a value greater than the number of held permits it has.

      Some strategy MIGHT throw an IllegalArgumentException if it can be determined the number of returned permits is not consistent with the strategy's limits and delivered permits.

    • warmupParallelism

      default int warmupParallelism()
      Return the concurrency level used when the allocator is subscribed to during the warmup phase, if any.

      The number of resources created concurrently will not exceed the value returned by warmupParallelism(). If the concurrency level is set to 1, pre-allocation of resources will be performed sequentially by subscribing to the allocator one at a time. The process waits for a resource to be created before subscribing again to the allocator. This sequence continues until all pre-allocated resources have been successfully created.

      Defaults to 1

      Returns:
      The concurrency level used when the allocator is subscribed to during the warmup phase, must be positive, 1 by default
      Since:
      1.0.1