org.vibur.objectpool.util

Class SamplingPoolReducer

java.lang.Object

org.vibur.objectpool.util.SamplingPoolReducer

All Implemented Interfaces:

ThreadedPoolReducer

public class SamplingPoolReducer
extends Object
implements ThreadedPoolReducer

A sampling pool reducer util, which is wakening up a given number of times during a predefined period of time, and checks whether the number of available allocated objects in the object pool needs to be reduced.

This pool reducer creates one daemon service thread which will be started when the reducer's start() method is called, and will be alive until the terminate() method is called or until the calling application exits.

Important specific to be mentioned is that if an exception is thrown during the pool reduction, which could be in this case a RuntimeException or an Error, the default implementation of the overridable afterReduce(int, int, Throwable) method will simply rethrow the exception, which will in turn terminate the reducer's background daemon thread.

Author:

Simeon Malchev

Constructor Summary

Constructors

Constructor and Description
SamplingPoolReducer(BasePoolService poolService, long timeInterval, TimeUnit unit, int samples) Creates a new SamplingPoolReducer with the given BasePoolService and timeInterval settings.

Method Summary

Methods

Modifier and Type	Method and Description
protected void	afterReduce(int reduction, int reduced, Throwable thrown) An after reduce pool hook.
protected int	calculateReduction()
Thread.State	getState() Returns the state of the underlying thread.
protected void	samplePool()
void	start() Starts this pool reducer, which starts its underlying daemon thread.
void	terminate() Terminates this pool reducer, which terminates its underlying daemon thread.

Methods inherited from class java.lang.Object

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

Constructor Detail

SamplingPoolReducer

public SamplingPoolReducer(BasePoolService poolService,
                   long timeInterval,
                   TimeUnit unit,
                   int samples)

Creates a new SamplingPoolReducer with the given BasePoolService and timeInterval settings. The created pool reducer is not started and needs to be explicitly started via call to start().

Parameters:

poolService - the pool service which is to be reduced if necessary

timeInterval - the time period after which the SamplingPoolReducer will try to possibly reduce the number of created but unused elements in the given poolService

unit - the time unit of the timeInterval argument

samples - how many times the SamplingPoolReducer will wake up during the given timeInterval period in order to sample various information from the given poolService

Throws:

IllegalArgumentException - if one of the following holds:
poolService == null || timeInterval <= 0 || unit == null || samples <= 0

Method Detail

start

public void start()

Starts this pool reducer, which starts its underlying daemon thread.

Specified by:

start in interface ThreadedPoolReducer

samplePool

protected void samplePool()

calculateReduction

protected int calculateReduction()

afterReduce

protected void afterReduce(int reduction,
               int reduced,
               Throwable thrown)

An after reduce pool hook. The default implementation does nothing. Note that if this method throws an Exception, it will terminate this SamplingPoolReducer.

Parameters:

reduction - the intended reduction

reduced - the number of objects removed/destroyed from the pool

thrown - a thrown exception if any (a RuntimeException or an Error)

getState

public Thread.State getState()

Returns the state of the underlying thread.

Specified by:

getState in interface ThreadedPoolReducer

Returns:

see above

terminate

public void terminate()

Terminates this pool reducer, which terminates its underlying daemon thread. Once terminated the pool reducer cannot be more revived.

Specified by:

terminate in interface ThreadedPoolReducer