Examples of org.apache.commons.pool.impl.GenericKeyedObjectPool

org.apache.commons.pool.impl.GenericKeyedObjectPool
A configurable KeyedObjectPool implementation.
When coupled with the appropriate {@link KeyedPoolableObjectFactory}, GenericKeyedObjectPool provides robust pooling functionality for keyed objects. A GenericKeyedObjectPool can be viewed as a map of pools, keyed on the (unique) key values provided to the {@link #preparePool preparePool}, {@link #addObject addObject} or{@link #borrowObject borrowObject} methods. Each time a new key value isprovided to one of these methods, a new pool is created under the given key to be managed by the containing GenericKeyedObjectPool.

A GenericKeyedObjectPool provides a number of configurable parameters:
- {@link #setMaxActive maxActive} controls the maximum number of objects(per key) that can allocated by the pool (checked out to client threads, or idle in the pool) at one time. When non-positive, there is no limit to the number of objects per key. When {@link #setMaxActive maxActive} isreached, the keyed pool is said to be exhausted. The default setting for this parameter is 8.
- {@link #setMaxTotal maxTotal} sets a global limit on the number of objectsthat can be in circulation (active or idle) within the combined set of pools. When non-positive, there is no limit to the total number of objects in circulation. When {@link #setMaxTotal maxTotal} is exceeded,all keyed pools are exhausted. When maxTotal is set to a positive value and {@link #borrowObject borrowObject} is invokedwhen at the limit with no idle instances available, an attempt is made to create room by clearing the oldest 15% of the elements from the keyed pools. The default setting for this parameter is -1 (no limit).
- {@link #setMaxIdle maxIdle} controls the maximum number of objects that cansit idle in the pool (per key) at any time. When negative, there is no limit to the number of objects that may be idle per key. The default setting for this parameter is 8.
- {@link #setWhenExhaustedAction whenExhaustedAction} specifies thebehavior of the {@link #borrowObject borrowObject} method when a keyedpool is exhausted:
  - When {@link #setWhenExhaustedAction whenExhaustedAction} is{@link #WHEN_EXHAUSTED_FAIL}, {@link #borrowObject borrowObject} will throwa {@link NoSuchElementException}
  - When {@link #setWhenExhaustedAction whenExhaustedAction} is{@link #WHEN_EXHAUSTED_GROW}, {@link #borrowObject borrowObject} will create a newobject and return it (essentially making {@link #setMaxActive maxActive}meaningless.)
  - When {@link #setWhenExhaustedAction whenExhaustedAction}is {@link #WHEN_EXHAUSTED_BLOCK}, {@link #borrowObject borrowObject} will block(invoke {@link Object#wait() wait} until a new or idle object is available.If a positive {@link #setMaxWait maxWait}value is supplied, the {@link #borrowObject borrowObject} will block for atmost that many milliseconds, after which a {@link NoSuchElementException}will be thrown. If {@link #setMaxWait maxWait} is non-positive,the {@link #borrowObject borrowObject} method will block indefinitely.
  The default whenExhaustedAction setting is {@link #WHEN_EXHAUSTED_BLOCK}.
- When {@link #setTestOnBorrow testOnBorrow} is set, the pool willattempt to validate each object before it is returned from the {@link #borrowObject borrowObject} method. (Using the provided factory's{@link KeyedPoolableObjectFactory#validateObject validateObject} method.)Objects that fail to validate will be dropped from the pool, and a different object will be borrowed. The default setting for this parameter is false.
- When {@link #setTestOnReturn testOnReturn} is set, the pool willattempt to validate each object before it is returned to the pool in the {@link #returnObject returnObject} method. (Using the provided factory's{@link KeyedPoolableObjectFactory#validateObject validateObject}method.) Objects that fail to validate will be dropped from the pool. The default setting for this parameter is false.
Optionally, one may configure the pool to examine and possibly evict objects as they sit idle in the pool and to ensure that a minimum number of idle objects is maintained for each key. This is performed by an "idle object eviction" thread, which runs asynchronously. Caution should be used when configuring this optional feature. Eviction runs require an exclusive synchronization lock on the pool, so if they run too frequently and / or incur excessive latency when creating, destroying or validating object instances, performance issues may result. The idle object eviction thread may be configured using the following attributes:
- {@link #setTimeBetweenEvictionRunsMillis timeBetweenEvictionRunsMillis}indicates how long the eviction thread should sleep before "runs" of examining idle objects. When non-positive, no eviction thread will be launched. The default setting for this parameter is -1 (i.e., by default, idle object eviction is disabled).
- {@link #setMinEvictableIdleTimeMillis minEvictableIdleTimeMillis}specifies the minimum amount of time that an object may sit idle in the pool before it is eligible for eviction due to idle time. When non-positive, no object will be dropped from the pool due to idle time alone. This setting has no effect unless timeBetweenEvictionRunsMillis > 0. The default setting for this parameter is 30 minutes.
- {@link #setTestWhileIdle testWhileIdle} indicates whether or not idleobjects should be validated using the factory's {@link KeyedPoolableObjectFactory#validateObject validateObject} methodduring idle object eviction runs. Objects that fail to validate will be dropped from the pool. This setting has no effect unless timeBetweenEvictionRunsMillis > 0. The default setting for this parameter is false.
- {@link #setMinIdle minIdle} sets a target value for the minimum number ofidle objects (per key) that should always be available. If this parameter is set to a positive number and timeBetweenEvictionRunsMillis > 0, each time the idle object eviction thread runs, it will try to create enough idle instances so that there will be minIdle idle instances available under each key. This parameter is also used by {@link #preparePool preparePool}if true is provided as that method's populateImmediately parameter. The default setting for this parameter is 0.
The pools can be configured to behave as LIFO queues with respect to idle objects - always returning the most recently used object from the pool, or as FIFO queues, where borrowObject always returns the oldest object in the idle object pool.
- {@link #setLifo Lifo}determines whether or not the pools return idle objects in last-in-first-out order. The default setting for this parameter is true.
GenericKeyedObjectPool is not usable without a {@link KeyedPoolableObjectFactory}. A non-null factory must be provided either as a constructor argument or via a call to {@link #setFactory setFactory} before the pool is used.

Implementation note: To prevent possible deadlocks, care has been taken to ensure that no call to a factory method will occur within a synchronization block. See POOL-125 and DBCP-44 for more information.
@see GenericObjectPool @author Rodney Waldhoff @author Dirk Verbeeck @author Sandy McArthur @version $Revision: 784441 $ $Date: 2009-06-13 13:42:28 -0400 (Sat, 13 Jun 2009) $ @since Pool 1.0

        final List calledMethods = new ArrayList();
        final Object key = new Object();


        // Test that the minIdle check doesn't add too many idle objects
        final KeyedPoolableObjectFactory kpof = (KeyedPoolableObjectFactory)createProxy(KeyedPoolableObjectFactory.class, calledMethods);
        final KeyedObjectPool kop = new GenericKeyedObjectPool(kpof);
        PoolUtils.checkMinIdle(kop, key, 2, 100);
        Thread.sleep(400);
        assertEquals(2, kop.getNumIdle(key));
        assertEquals(2, kop.getNumIdle());
        kop.close();
        int makeObjectCount = 0;
        final Iterator iter = calledMethods.iterator();
        while (iter.hasNext()) {
            final String methodName = (String)iter.next();
            if ("makeObject".equals(methodName)) {

View Full Code Here

            config.maxActive = poolSize;
            config.testOnBorrow = true;
            config.whenExhaustedAction = GenericKeyedObjectPool.WHEN_EXHAUSTED_BLOCK;
            config.maxWait = 10000;
            StringPoolableObjectFactory objFactory = new StringPoolableObjectFactory();
            final KeyedObjectPool pool = new GenericKeyedObjectPool(objFactory, config);
            PerformanceTest test = new PerformanceTest() {


                @Override
                public void doOperation(int id) throws Exception {
                    Integer key = id % numKeys;
                    String s = (String) pool.borrowObject(key);
                    pool.returnObject(key, s);
                }
            };
            test.run(numRequests, numThreads);
            test.printStats();
            System.out.println();

View Full Code Here

   }


   public void testClosedConnection() throws Exception {
      rc.put("k","v"); //make sure a connection is created


      GenericKeyedObjectPool keyedObjectPool = transportFactory.getConnectionPool();
      InetSocketAddress address = new InetSocketAddress("127.0.0.1", hotRodServer.getPort());


      assertEquals(0, keyedObjectPool.getNumActive(address));
      assertEquals(1, keyedObjectPool.getNumIdle(address));


      TcpTransport tcpConnection = (TcpTransport) keyedObjectPool.borrowObject(address);
      keyedObjectPool.returnObject(address, tcpConnection);//now we have a reference to the single connection in pool


      tcpConnection.destroy();


      assertEquals("v", rc.get("k"));
      assertEquals(0, keyedObjectPool.getNumActive(address));
      assertEquals(1, keyedObjectPool.getNumIdle(address));


      TcpTransport tcpConnection2 = (TcpTransport) keyedObjectPool.borrowObject(address);


      assert tcpConnection2.getId() != tcpConnection.getId();
   }

View Full Code Here


    private final GenericKeyedObjectPool pool;


    public DefaultConfigurableKeyedObjectPool()
    {
        pool = new GenericKeyedObjectPool();


        // NOTE: testOnBorrow MUST be FALSE. this is a bit of a design bug in
        // commons-pool since validate is used for both activation and passivation,
        // but has no way of knowing which way it is going.
        pool.setTestOnBorrow(false);

View Full Code Here

        final List calledMethods = new ArrayList();
        final Object key = new Object();


        // Test that the minIdle check doesn't add too many idle objects
        final KeyedPoolableObjectFactory kpof = (KeyedPoolableObjectFactory)createProxy(KeyedPoolableObjectFactory.class, calledMethods);
        final KeyedObjectPool kop = new GenericKeyedObjectPool(kpof);
        PoolUtils.checkMinIdle(kop, key, 2, 100);
        Thread.sleep(400);
        assertEquals(2, kop.getNumIdle(key));
        assertEquals(2, kop.getNumIdle());
        kop.close();
        int makeObjectCount = 0;
        final Iterator iter = calledMethods.iterator();
        while (iter.hasNext()) {
            final String methodName = (String)iter.next();
            if ("makeObject".equals(methodName)) {

View Full Code Here

     */
    GenericKeyedObjectPool _pool;


    public void initializeService()
    {
        _pool = new GenericKeyedObjectPool(this);


        _pool.setMaxActive(Integer.parseInt(_propertySource.getPropertyValue("org.apache.tapestry.page-pool-max-active")));
        _pool.setMaxIdle(Integer.parseInt(_propertySource.getPropertyValue("org.apache.tapestry.page-pool-max-idle")));


        _pool.setMinIdle(Integer.parseInt(_propertySource.getPropertyValue("org.apache.tapestry.page-pool-min-idle")));

View Full Code Here

        throws javax.naming.NamingException, SQLException {


        ConnectionPoolDataSource cpds = testCPDS(username, password);


        // Create an object pool to contain our PooledConnections
        GenericKeyedObjectPool tmpPool = new GenericKeyedObjectPool(null);
        tmpPool.setMaxActive(getMaxActive());
        tmpPool.setMaxIdle(getMaxIdle());
        tmpPool.setMaxWait(getMaxWait());
        tmpPool.setWhenExhaustedAction(whenExhaustedAction(maxActive, maxWait));
        tmpPool.setTestOnBorrow(getTestOnBorrow());
        tmpPool.setTestOnReturn(getTestOnReturn());
        tmpPool.setTimeBetweenEvictionRunsMillis(
            getTimeBetweenEvictionRunsMillis());
        tmpPool.setNumTestsPerEvictionRun(getNumTestsPerEvictionRun());
        tmpPool.setMinEvictableIdleTimeMillis(getMinEvictableIdleTimeMillis());
        tmpPool.setTestWhileIdle(getTestWhileIdle());
        pool = tmpPool;
        // Set up the factory we will use (passing the pool associates
        // the factory with the pool, so we do not have to do so
        // explicitly)
        new KeyedCPDSConnectionFactory(cpds, pool, getValidationQuery());

View Full Code Here

        int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, 
        boolean testWhileIdle) {
        */
        KeyedObjectPool stmtPool = null;
        if (isPoolPreparedStatements()) {
            stmtPool = new GenericKeyedObjectPool(null,
                getMaxActive(), GenericKeyedObjectPool.WHEN_EXHAUSTED_GROW, 0, 
                getMaxIdle(), false, false, getTimeBetweenEvictionRunsMillis(),
                getNumTestsPerEvictionRun(), 
                getMinEvictableIdleTimeMillis(), false);            
        }

View Full Code Here

     */
    GenericKeyedObjectPool _pool;


    public void initializeService()
    {
        _pool = new GenericKeyedObjectPool(this);


        _pool.setMaxActive(Integer.parseInt(_propertySource.getPropertyValue("org.apache.tapestry.page-pool-max-active")));
        _pool.setMaxIdle(Integer.parseInt(_propertySource.getPropertyValue("org.apache.tapestry.page-pool-max-idle")));


        _pool.setMinIdle(Integer.parseInt(_propertySource.getPropertyValue("org.apache.tapestry.page-pool-min-idle")));

View Full Code Here

        if (isPoolPreparedStatements()) {
            if (getMaxPreparedStatements() <= 0)
            {
                // since there is no limit, create a prepared statement pool with an eviction thread
                //  evictor settings are the same as the connection pool settings.
                stmtPool = new GenericKeyedObjectPool(null,
                    getMaxActive(), GenericKeyedObjectPool.WHEN_EXHAUSTED_GROW, 0,
                    getMaxIdle(), false, false,
                    getTimeBetweenEvictionRunsMillis(),getNumTestsPerEvictionRun(),getMinEvictableIdleTimeMillis(),
                    false);
            }
            else
            {
                // since there is limit, create a prepared statement pool without an eviction thread
                //  pool has LRU functionality so when the limit is reached, 15% of the pool is cleared.
                // see org.apache.commons.pool.impl.GenericKeyedObjectPool.clearOldest method
                stmtPool = new GenericKeyedObjectPool(null,
                    getMaxActive(), GenericKeyedObjectPool.WHEN_EXHAUSTED_GROW, 0,
                    getMaxIdle(), getMaxPreparedStatements(), false, false,
                    -1,0,0, // -1 tells the pool that there should be no eviction thread.
                    false);
            }

View Full Code Here

0 1 2 3

TOP

Related Classes of org.apache.commons.pool.impl.GenericKeyedObjectPool

com.alibaba.otter.shared.communication.core.impl.connection.CommunicationConnectionPoolFactory

org.apache.commons.collections.CursorableLinkedList

org.apache.commons.dbcp.cpdsadapter.DriverAdapterCPDS

org.apache.commons.dbcp.datasources.SharedPoolDataSource

org.apache.commons.dbcp.datasources.TestKeyedCPDSConnectionFactory

org.apache.commons.dbcp.jdbc2pool.Jdbc2PoolDataSource

org.apache.commons.dbcp.TestDelegatingConnection

org.apache.commons.pool.KeyedPoolableObjectFactory

org.apache.commons.pool.TestPoolUtils

org.apache.ojb.broker.core.PersistenceBrokerFactoryDefaultImpl

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.