/** * Create a new <code>SimpleKeyedObjectPool</code> using * the specified <code>factory</code> to create new instances. * capping the number of "sleeping" instances to <code>max</code>, * and initially allocating a container capable of containing * at least <code>init</code> instances. * * @param factory the {@link KeyedPoolableObjectFactory} used to populate the pool * @param max cap on the number of "sleeping" instances in the pool * @param init initial size of the pool (this specifies the size of the container, * it does not cause the pool to be pre-populated.) */ public StackKeyedObjectPool(KeyedPoolableObjectFactory <K, V> factory, int max, int init) { _factory = factory; _maxSleeping = (max < 0 ? DEFAULT_MAX_SLEEPING : max); _initSleepingCapacity = (init < 1 ? DEFAULT_INIT_SLEEPING_CAPACITY : init); _pools = new java.util.HashMap <K, java.util.Stack <V> >(); _activeCount = new java.util.HashMap <K, java.lang.Integer>(); }
/** * Create a new GenericKeyedObjectPoolFactory. * * @param factory the KeyedPoolableObjectFactory to used by created pools. * @see GenericKeyedObjectPool#GenericKeyedObjectPool(KeyedPoolableObjectFactory) */ public GenericKeyedObjectPoolFactory(KeyedPoolableObjectFactory <K, V> factory) : this(factory, GenericKeyedObjectPool <K, V> .DEFAULT_MAX_ACTIVE, GenericKeyedObjectPool <K, V> .DEFAULT_WHEN_EXHAUSTED_ACTION, GenericKeyedObjectPool <K, V> .DEFAULT_MAX_WAIT, GenericKeyedObjectPool <K, V> .DEFAULT_MAX_IDLE, GenericKeyedObjectPool <K, V> .DEFAULT_TEST_ON_BORROW, GenericKeyedObjectPool <K, V> .DEFAULT_TEST_ON_RETURN, GenericKeyedObjectPool <K, V> .DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS, GenericKeyedObjectPool <K, V> .DEFAULT_NUM_TESTS_PER_EVICTION_RUN, GenericKeyedObjectPool <K, V> .DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS, GenericKeyedObjectPool <K, V> .DEFAULT_TEST_WHILE_IDLE) { }
public void setFactory(KeyedPoolableObjectFactory <K, V> factory) {// throws IllegalStateException { lock (this) { if (0 < getNumActive()) { throw new java.lang.IllegalStateException("Objects are already active"); } else { clear(); _factory = factory; } } }
/** * Create a new GenericKeyedObjectPoolFactory. * * @param factory the KeyedPoolableObjectFactory to used by created pools. * @param maxActive the maximum number of objects that can be borrowed from pools at one time. * @param whenExhaustedAction the action to take when the pool is exhausted. * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted. * @param maxIdle the maximum number of idle objects in the pools. * @param maxTotal the maximum number of objects that can exists at one time. * @param minIdle the minimum number of idle objects to have in the pool at any one time. * @param testOnBorrow whether to validate objects before they are returned by borrowObject. * @param testOnReturn whether to validate objects after they are returned to returnObject. * @param timeBetweenEvictionRunsMillis the number of milliseconds to sleep between examining idle objects for eviction. * @param numTestsPerEvictionRun the number of idle objects to examine per run of the evictor. * @param minEvictableIdleTimeMillis the minimum number of milliseconds an object can sit idle in the pool before it is eligible for eviction. * @param testWhileIdle whether to validate objects in the idle object eviction thread. * @param lifo whether or not objects are returned in last-in-first-out order from the idle object pool. * @since Pool 1.4 * @see GenericKeyedObjectPool#GenericKeyedObjectPool(KeyedPoolableObjectFactory, int, byte, long, int, int, int, bool, bool, long, int, long, bool, bool) */ public GenericKeyedObjectPoolFactory(KeyedPoolableObjectFactory <K, V> factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, int maxTotal, int minIdle, bool testOnBorrow, bool testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, bool testWhileIdle, bool lifo) { _maxIdle = maxIdle; _maxActive = maxActive; _maxTotal = maxTotal; _minIdle = minIdle; _maxWait = maxWait; _whenExhaustedAction = whenExhaustedAction; _testOnBorrow = testOnBorrow; _testOnReturn = testOnReturn; _testWhileIdle = testWhileIdle; _timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis; _numTestsPerEvictionRun = numTestsPerEvictionRun; _minEvictableIdleTimeMillis = minEvictableIdleTimeMillis; _factory = factory; _lifo = lifo; }
/** * Create a new <code>SimpleKeyedObjectPool</code> using * the specified <code>factory</code> to create new instances. * * @param factory the {@link KeyedPoolableObjectFactory} used to populate the pool */ public StackKeyedObjectPool(KeyedPoolableObjectFactory <K, V> factory) : this(factory, DEFAULT_MAX_SLEEPING) { }
/** * Create a new <code>SimpleKeyedObjectPool</code> using * the specified <code>factory</code> to create new instances. * capping the number of "sleeping" instances to <code>max</code> * * @param factory the {@link KeyedPoolableObjectFactory} used to populate the pool * @param max cap on the number of "sleeping" instances in the pool */ public StackKeyedObjectPool(KeyedPoolableObjectFactory <K, V> factory, int max) : this(factory, max, DEFAULT_INIT_SLEEPING_CAPACITY) { }
/** * Create a new StackKeyedObjectPoolFactory. * * @param factory the KeyedPoolableObjectFactory used by created pools. * @param maxSleeping cap on the number of "sleeping" instances in the pool. * @see StackKeyedObjectPool#StackKeyedObjectPool(KeyedPoolableObjectFactory, int) */ public StackKeyedObjectPoolFactory(KeyedPoolableObjectFactory <K, V> factory, int maxSleeping) : this(factory, maxSleeping, StackKeyedObjectPool <K, V> .DEFAULT_INIT_SLEEPING_CAPACITY) { }
/** * Create a new StackKeyedObjectPoolFactory. * * @param factory the KeyedPoolableObjectFactory used by created pools. * @see StackKeyedObjectPool#StackKeyedObjectPool(KeyedPoolableObjectFactory) */ public StackKeyedObjectPoolFactory(KeyedPoolableObjectFactory <K, V> factory) : this(factory, StackKeyedObjectPool <K, V> .DEFAULT_MAX_SLEEPING, StackKeyedObjectPool <K, V> .DEFAULT_INIT_SLEEPING_CAPACITY) { }
/** * Create a new StackKeyedObjectPoolFactory. * * @param factory the KeyedPoolableObjectFactory used by created pools. * @param maxSleeping cap on the number of "sleeping" instances in the pool. * @param initialCapacity initial size of the pool (this specifies the size of the container, * it does not cause the pool to be pre-populated.) * @see StackKeyedObjectPool#StackKeyedObjectPool(KeyedPoolableObjectFactory, int, int) */ public StackKeyedObjectPoolFactory(KeyedPoolableObjectFactory <K, V> factory, int maxSleeping, int initialCapacity) { _factory = factory; _maxSleeping = maxSleeping; _initCapacity = initialCapacity; }
public virtual void setFactory(KeyedPoolableObjectFactory <K, V> factory) {// throws IllegalStateException, UnsupportedOperationException { throw new java.lang.UnsupportedOperationException(); }
/** * Create a new GenericKeyedObjectPoolFactory. * * @param factory the KeyedPoolableObjectFactory to used by created pools. * @param maxActive the maximum number of objects that can be borrowed from pools at one time. * @param whenExhaustedAction the action to take when the pool is exhausted. * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted. * @see GenericKeyedObjectPool#GenericKeyedObjectPool(KeyedPoolableObjectFactory, int, byte, long) */ public GenericKeyedObjectPoolFactory(KeyedPoolableObjectFactory <K, V> factory, int maxActive, byte whenExhaustedAction, long maxWait) : this(factory, maxActive, whenExhaustedAction, maxWait, GenericKeyedObjectPool <K, V> .DEFAULT_MAX_IDLE, GenericKeyedObjectPool <K, V> .DEFAULT_MAX_TOTAL, GenericKeyedObjectPool <K, V> .DEFAULT_TEST_ON_BORROW, GenericKeyedObjectPool <K, V> .DEFAULT_TEST_ON_RETURN, GenericKeyedObjectPool <K, V> .DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS, GenericKeyedObjectPool <K, V> .DEFAULT_NUM_TESTS_PER_EVICTION_RUN, GenericKeyedObjectPool <K, V> .DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS, GenericKeyedObjectPool <K, V> .DEFAULT_TEST_WHILE_IDLE) { }
/** * Create a new GenericKeyedObjectPoolFactory. * * @param factory the KeyedPoolableObjectFactory to used by created pools. * @param config a non-null GenericKeyedObjectPool<K,V>.Config describing the configuration. * @see GenericKeyedObjectPool#GenericKeyedObjectPool(KeyedPoolableObjectFactory, GenericKeyedObjectPool<K,V>.Config) * @throws NullPointerException when config is <code>null</code>. */ public GenericKeyedObjectPoolFactory(KeyedPoolableObjectFactory <K, V> factory, GenericKeyedObjectPool <K, V> .Config config) ://throws NullPointerException { this(factory, config.maxActive, config.whenExhaustedAction, config.maxWait, config.maxIdle, config.maxTotal, config.minIdle, config.testOnBorrow, config.testOnReturn, config.timeBetweenEvictionRunsMillis, config.numTestsPerEvictionRun, config.minEvictableIdleTimeMillis, config.testWhileIdle, config.lifo) { }
/** * Create a new GenericKeyedObjectPoolFactory. * * @param factory the KeyedPoolableObjectFactory to used by created pools. * @param maxActive the maximum number of objects that can be borrowed from pools at one time. * @param whenExhaustedAction the action to take when the pool is exhausted. * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted. * @param maxIdle the maximum number of idle objects in the pools. * @param maxTotal the maximum number of objects that can exists at one time. * @param minIdle the minimum number of idle objects to have in the pool at any one time. * @param testOnBorrow whether to validate objects before they are returned by borrowObject. * @param testOnReturn whether to validate objects after they are returned to returnObject. * @param timeBetweenEvictionRunsMillis the number of milliseconds to sleep between examining idle objects for eviction. * @param numTestsPerEvictionRun the number of idle objects to examine per run of the evictor. * @param minEvictableIdleTimeMillis the minimum number of milliseconds an object can sit idle in the pool before it is eligible for eviction. * @param testWhileIdle whether to validate objects in the idle object eviction thread. * @since Pool 1.3 * @see GenericKeyedObjectPool#GenericKeyedObjectPool(KeyedPoolableObjectFactory, int, byte, long, int, int, int, bool, bool, long, int, long, bool) */ public GenericKeyedObjectPoolFactory(KeyedPoolableObjectFactory <K, V> factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, int maxTotal, int minIdle, bool testOnBorrow, bool testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, bool testWhileIdle) : this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle, maxTotal, minIdle, testOnBorrow, testOnReturn, timeBetweenEvictionRunsMillis, numTestsPerEvictionRun, minEvictableIdleTimeMillis, testWhileIdle, GenericKeyedObjectPool <K, V> .DEFAULT_LIFO) { }
/** * Create a new GenericKeyedObjectPoolFactory. * * @param factory the KeyedPoolableObjectFactory to used by created pools. * @param maxActive the maximum number of objects that can be borrowed from pools at one time. * @param whenExhaustedAction the action to take when the pool is exhausted. * @param maxWait the maximum amount of time to wait for an idle object when the pool is exhausted. * @param maxIdle the maximum number of idle objects in the pools. * @param testOnBorrow whether to validate objects before they are returned by borrowObject. * @param testOnReturn whether to validate objects after they are returned to returnObject. * @see GenericKeyedObjectPool#GenericKeyedObjectPool(KeyedPoolableObjectFactory, int, byte, long, int, bool, bool) */ public GenericKeyedObjectPoolFactory(KeyedPoolableObjectFactory <K, V> factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, bool testOnBorrow, bool testOnReturn) : this(factory, maxActive, whenExhaustedAction, maxWait, maxIdle, GenericKeyedObjectPool <K, V> .DEFAULT_MAX_TOTAL, testOnBorrow, testOnReturn, GenericKeyedObjectPool <K, V> .DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS, GenericKeyedObjectPool <K, V> .DEFAULT_NUM_TESTS_PER_EVICTION_RUN, GenericKeyedObjectPool <K, V> .DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS, GenericKeyedObjectPool <K, V> .DEFAULT_TEST_WHILE_IDLE) { }
/// <summary> /// Create an KeyedObjectPool with the specified factory. The pool should be in a /// default configuration and conform to the expected behaviors described in KeyedObjectPool. /// Generally speaking there should be no limits on the various object counts. /// </summary> protected abstract KeyedObjectPool <Object, Object> MakeEmptyPool(KeyedPoolableObjectFactory <Object, Object> factory);
protected abstract KeyedObjectPoolFactory <Object, Object> MakeFactory(KeyedPoolableObjectFactory <Object, Object> objectFactory);