DefaultPoolConfig (Reactor Pool 1.1.0-M1)

java.lang.Object
- reactor.pool.DefaultPoolConfig<POOLABLE>

All Implemented Interfaces:

PoolConfig<POOLABLE>
```
public class DefaultPoolConfig<POOLABLE>
extends Object
implements PoolConfig<POOLABLE>
```
A default PoolConfig that can be extended to bear more configuration options with access to a copy constructor for the basic options.

Author:

Simon Baslé

Field Summary

Fields
Modifier and Type	Field and Description
`protected Scheduler`	`acquisitionScheduler`
`protected AllocationStrategy`	`allocationStrategy`
`protected Mono<POOLABLE>`	`allocator`
`protected Clock`	`clock`
`protected Function<POOLABLE,? extends Publisher<Void>>`	`destroyHandler`
`protected Duration`	`evictInBackgroundInterval`
`protected Scheduler`	`evictInBackgroundScheduler`
`protected BiPredicate<POOLABLE,PooledRefMetadata>`	`evictionPredicate`
`protected boolean`	`isIdleLRU`
`protected int`	`maxPending`
`protected PoolMetricsRecorder`	`metricsRecorder`
`protected BiFunction<Runnable,Duration,Disposable>`	`pendingAcquireTimer`
`protected Function<POOLABLE,? extends Publisher<Void>>`	`releaseHandler`

Constructor Summary

Constructors
Modifier	Constructor and Description
	DefaultPoolConfig(Mono<POOLABLE> allocator, AllocationStrategy allocationStrategy, int maxPending, BiFunction<Runnable,Duration,Disposable> pendingAcquireTimer, Function<POOLABLE,? extends Publisher<Void>> releaseHandler, Function<POOLABLE,? extends Publisher<Void>> destroyHandler, BiPredicate<POOLABLE,PooledRefMetadata> evictionPredicate, Duration evictInBackgroundInterval, Scheduler evictInBackgroundScheduler, Scheduler acquisitionScheduler, PoolMetricsRecorder metricsRecorder, Clock clock, boolean isIdleLRU)
`protected`	`DefaultPoolConfig(PoolConfig<POOLABLE> toCopy)` Copy constructor for the benefit of specializations of `PoolConfig`.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Scheduler`	`acquisitionScheduler()` When set, `Pool` implementation MAY decide to use the `Scheduler` to publish resources in a more deterministic way: the publishing thread would then always be the same, independently of which thread called `Pool.acquire()` or `PooledRef.release()` or on which thread the `PoolConfig.allocator()` produced new resources.
`AllocationStrategy`	`allocationStrategy()` `AllocationStrategy` defines a strategy / limit for the number of pooled object to allocate.
`Mono<POOLABLE>`	`allocator()` The asynchronous factory that produces new resources, represented as a `Mono`.
`Clock`	`clock()` The `Clock` to use to timestamp pool lifecycle events like allocation and eviction, which can influence eg.
`Function<POOLABLE,? extends Publisher<Void>>`	`destroyHandler()` Defines a mechanism of resource destruction, cleaning up state and OS resources it could maintain (eg.
`Duration`	`evictInBackgroundInterval()` If the pool is configured to perform regular eviction checks on the background, returns the `Duration` representing the interval at which such checks are made.
`Scheduler`	`evictInBackgroundScheduler()` If the pool is configured to perform regular eviction checks on the background, returns the `Scheduler` on which these checks are made.
`BiPredicate<POOLABLE,PooledRefMetadata>`	`evictionPredicate()` A `BiPredicate` that checks if a resource should be destroyed (`true`) or is still in a valid state for recycling.
`int`	`maxPending()` The maximum number of pending borrowers to enqueue before failing fast.
`PoolMetricsRecorder`	`metricsRecorder()` The `PoolMetricsRecorder` to use to collect instrumentation data of the `Pool` implementations.
`BiFunction<Runnable,Duration,Disposable>`	`pendingAcquireTimer()` The function that defines how timeouts are scheduled when a `Pool.acquire(Duration)` call is made and the acquisition is pending.
`Function<POOLABLE,? extends Publisher<Void>>`	`releaseHandler()` When a resource is `released`, defines a mechanism of resetting any lingering state of the resource in order for it to become usable again.
`boolean`	`reuseIdleResourcesInLruOrder()` The order in which idle (aka available) resources should be used when the pool was under-utilized and a new `Pool.acquire()` is performed.

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

- Field Detail
  - pendingAcquireTimer
```
protected final BiFunction<Runnable,Duration,Disposable> pendingAcquireTimer
```
  - allocator
```
protected final Mono<POOLABLE> allocator
```
  - allocationStrategy
```
protected final AllocationStrategy allocationStrategy
```
  - maxPending
```
protected final int maxPending
```
  - releaseHandler
```
protected final Function<POOLABLE,? extends Publisher<Void>> releaseHandler
```
  - destroyHandler
```
protected final Function<POOLABLE,? extends Publisher<Void>> destroyHandler
```
  - evictionPredicate
```
protected final BiPredicate<POOLABLE,PooledRefMetadata> evictionPredicate
```
  - evictInBackgroundInterval
```
protected final Duration evictInBackgroundInterval
```
  - evictInBackgroundScheduler
```
protected final Scheduler evictInBackgroundScheduler
```
  - acquisitionScheduler
```
protected final Scheduler acquisitionScheduler
```
  - metricsRecorder
```
protected final PoolMetricsRecorder metricsRecorder
```
  - clock
```
protected final Clock clock
```
  - isIdleLRU
```
protected final boolean isIdleLRU
```
- Constructor Detail
  - DefaultPoolConfig
```
public DefaultPoolConfig(Mono<POOLABLE> allocator,
                         AllocationStrategy allocationStrategy,
                         int maxPending,
                         BiFunction<Runnable,Duration,Disposable> pendingAcquireTimer,
                         Function<POOLABLE,? extends Publisher<Void>> releaseHandler,
                         Function<POOLABLE,? extends Publisher<Void>> destroyHandler,
                         BiPredicate<POOLABLE,PooledRefMetadata> evictionPredicate,
                         Duration evictInBackgroundInterval,
                         Scheduler evictInBackgroundScheduler,
                         Scheduler acquisitionScheduler,
                         PoolMetricsRecorder metricsRecorder,
                         Clock clock,
                         boolean isIdleLRU)
```
  - DefaultPoolConfig
```
protected DefaultPoolConfig(PoolConfig<POOLABLE> toCopy)
```
    Copy constructor for the benefit of specializations of PoolConfig.
    
    Parameters:
    
    toCopy - the original PoolConfig to copy (only standard PoolConfig options are copied)
- Method Detail
  - allocator
```
public Mono<POOLABLE> allocator()
```
    Description copied from interface: PoolConfig
    
    The asynchronous factory that produces new resources, represented as a Mono.
    
    Specified by:
    
    allocator in interface PoolConfig<POOLABLE>
  - allocationStrategy
```
public AllocationStrategy allocationStrategy()
```
    Description copied from interface: PoolConfig
    
    AllocationStrategy defines a strategy / limit for the number of pooled object to allocate.
    
    Specified by:
    
    allocationStrategy in interface PoolConfig<POOLABLE>
  - maxPending
```
public int maxPending()
```
    Description copied from interface: PoolConfig
    
    The maximum number of pending borrowers to enqueue before failing fast. 0 will immediately fail any acquire when no idle resource is available and the pool cannot grow. Use a negative number to deactivate.
    
    Specified by:
    
    maxPending in interface PoolConfig<POOLABLE>
  - pendingAcquireTimer
```
public BiFunction<Runnable,Duration,Disposable> pendingAcquireTimer()
```
    Description copied from interface: PoolConfig
    
    The function that defines how timeouts are scheduled when a Pool.acquire(Duration) call is made and the acquisition is pending. i.e. there is no idle resource and no new resource can be created currently, so a timeout is scheduled using the returned function.
    By default, the Schedulers.parallel() scheduler is used.
    
    Specified by:
    
    pendingAcquireTimer in interface PoolConfig<POOLABLE>
    
    Returns:
    
    the function to apply when scheduling timers for pending acquisitions
  - releaseHandler
```
public Function<POOLABLE,? extends Publisher<Void>> releaseHandler()
```
    Description copied from interface: PoolConfig
    
    When a resource is released, defines a mechanism of resetting any lingering state of the resource in order for it to become usable again. The PoolConfig.evictionPredicate() is applied AFTER this reset.
    For example, a buffer could have a readerIndex and writerIndex that need to be flipped back to zero.
    
    Specified by:
    
    releaseHandler in interface PoolConfig<POOLABLE>
  - destroyHandler
```
public Function<POOLABLE,? extends Publisher<Void>> destroyHandler()
```
    Description copied from interface: PoolConfig
    
    Defines a mechanism of resource destruction, cleaning up state and OS resources it could maintain (eg. off-heap objects, file handles, socket connections, etc...).
    For example, a database connection could need to cleanly sever the connection link by sending a message to the database.
    
    Specified by:
    
    destroyHandler in interface PoolConfig<POOLABLE>
  - evictionPredicate
```
public BiPredicate<POOLABLE,PooledRefMetadata> evictionPredicate()
```
    Description copied from interface: PoolConfig
    
    A BiPredicate that checks if a resource should be destroyed (true) or is still in a valid state for recycling. This is primarily applied when a resource is released, to check whether or not it can immediately be recycled, but could also be applied during an acquire attempt (detecting eg. idle resources) or by a background reaping process. Both the resource and some metrics about the resource's life within the pool are provided.
    
    Specified by:
    
    evictionPredicate in interface PoolConfig<POOLABLE>
  - evictInBackgroundInterval
```
public Duration evictInBackgroundInterval()
```
    Description copied from interface: PoolConfig
    
    If the pool is configured to perform regular eviction checks on the background, returns the Duration representing the interval at which such checks are made. Otherwise returns Duration.ZERO (the default).
    
    Specified by:
    
    evictInBackgroundInterval in interface PoolConfig<POOLABLE>
  - evictInBackgroundScheduler
```
public Scheduler evictInBackgroundScheduler()
```
    Description copied from interface: PoolConfig
    
    If the pool is configured to perform regular eviction checks on the background, returns the Scheduler on which these checks are made. Otherwise returns Schedulers.immediate() (the default).
    
    Specified by:
    
    evictInBackgroundScheduler in interface PoolConfig<POOLABLE>
  - acquisitionScheduler
```
public Scheduler acquisitionScheduler()
```
    Description copied from interface: PoolConfig
    
    When set, Pool implementation MAY decide to use the Scheduler to publish resources in a more deterministic way: the publishing thread would then always be the same, independently of which thread called Pool.acquire() or PooledRef.release() or on which thread the PoolConfig.allocator() produced new resources. Note that not all pool implementations are guaranteed to enforce this, as they might have their own thread publishing semantics.
    Defaults to Schedulers.immediate(), which inhibits this behavior.
    
    Specified by:
    
    acquisitionScheduler in interface PoolConfig<POOLABLE>
  - metricsRecorder
```
public PoolMetricsRecorder metricsRecorder()
```
    Description copied from interface: PoolConfig
    
    The PoolMetricsRecorder to use to collect instrumentation data of the Pool implementations.
    
    Specified by:
    
    metricsRecorder in interface PoolConfig<POOLABLE>
  - clock
```
public Clock clock()
```
    Description copied from interface: PoolConfig
    
    The Clock to use to timestamp pool lifecycle events like allocation and eviction, which can influence eg. the PoolConfig.evictionPredicate().
    
    Specified by:
    
    clock in interface PoolConfig<POOLABLE>
  - reuseIdleResourcesInLruOrder
```
public boolean reuseIdleResourcesInLruOrder()
```
    Description copied from interface: PoolConfig
    
    The order in which idle (aka available) resources should be used when the pool was under-utilized and a new Pool.acquire() is performed. Returns true if LRU (Least-Recently Used, the resource that was released first is emitted) or false for MRU (Most-Recently Used, the resource that was released last is emitted).
    
    Specified by:
    
    reuseIdleResourcesInLruOrder in interface PoolConfig<POOLABLE>
    
    Returns:
    
    true for LRU, false for MRU

Class DefaultPoolConfig<POOLABLE>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

pendingAcquireTimer

allocator

allocationStrategy

maxPending

releaseHandler

destroyHandler

evictionPredicate

evictInBackgroundInterval

evictInBackgroundScheduler

acquisitionScheduler

metricsRecorder

clock

isIdleLRU

Constructor Detail

DefaultPoolConfig

DefaultPoolConfig

Method Detail

allocator

allocationStrategy

maxPending

pendingAcquireTimer

releaseHandler

destroyHandler

evictionPredicate

evictInBackgroundInterval

evictInBackgroundScheduler

acquisitionScheduler

metricsRecorder

clock

reuseIdleResourcesInLruOrder