Examples of GenericObjectPool

org.apache.commons.pool.impl.GenericObjectPool
A configurable {@link ObjectPool} implementation.
When coupled with the appropriate {@link PoolableObjectFactory}, GenericObjectPool provides robust pooling functionality for arbitrary objects.
A GenericObjectPool provides a number of configurable parameters:
- {@link #setMaxActive maxActive} controls the maximum number ofobjects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. When non-positive, there is no limit to the number of objects that can be managed by the pool at one time. When {@link #setMaxActive maxActive} is reached, the pool is saidto be exhausted. The default setting for this parameter is 8.
- {@link #setMaxIdle maxIdle} controls the maximum number of objectsthat can sit idle in the pool at any time. When negative, there is no limit to the number of objects that may be idle at one time. The default setting for this parameter is 8.
- {@link #setWhenExhaustedAction whenExhaustedAction} specifies thebehavior of the {@link #borrowObject} method when the pool is exhausted:
  - When {@link #setWhenExhaustedAction whenExhaustedAction} is{@link #WHEN_EXHAUSTED_FAIL}, {@link #borrowObject} will throwa {@link NoSuchElementException}
  - When {@link #setWhenExhaustedAction whenExhaustedAction} is{@link #WHEN_EXHAUSTED_GROW}, {@link #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} will block(invoke {@link Object#wait()}) until a new or idle object is available. If a positive {@link #setMaxWait maxWait}value is supplied, then {@link #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} method will block indefinitely.
  The default whenExhaustedAction setting is {@link #WHEN_EXHAUSTED_BLOCK} and the default maxWaitsetting is -1. By default, therefore, borrowObject will block indefinitely until an idle instance becomes available.
- When {@link #setTestOnBorrow testOnBorrow} is set, the pool willattempt to validate each object before it is returned from the {@link #borrowObject} method. (Using the provided factory's{@link PoolableObjectFactory#validateObject} method.) Objects that failto 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} method. (Using the provided factory's{@link PoolableObjectFactory#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 are available. 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., idle object eviction is disabled by default).
- {@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 PoolableObjectFactory#validateObject} method. Objects that fail tovalidate will be dropped from the pool. This setting has no effect unless timeBetweenEvictionRunsMillis > 0. The default setting for this parameter is false.
- {@link #setSoftMinEvictableIdleTimeMillis softMinEvictableIdleTimeMillis}specifies the minimum amount of time an object may sit idle in the pool before it is eligible for eviction by the idle object evictor (if any), with the extra condition that at least "minIdle" object instances remain in the pool. When non-positive, no objects will be evicted from the pool due to idle time alone. This setting has no effect unless timeBetweenEvictionRunsMillis > 0. and it is superceded by {@link #setMinEvictableIdleTimeMillis minEvictableIdleTimeMillis}(that is, if minEvictableIdleTimeMillis is positive, then softMinEvictableIdleTimeMillis is ignored). The default setting for this parameter is -1 (disabled).
- {@link #setNumTestsPerEvictionRun numTestsPerEvictionRun}determines the number of objects examined in each run of the idle object evictor. This setting has no effect unless timeBetweenEvictionRunsMillis > 0. The default setting for this parameter is 3.
The pool can be configured to behave as a LIFO queue with respect to idle objects - always returning the most recently used object from the pool, or as a FIFO queue, where borrowObject always returns the oldest object in the idle object pool.
- {@link #setLifo lifo}determines whether or not the pool returns idle objects in last-in-first-out order. The default setting for this parameter is true.
GenericObjectPool is not usable without a {@link PoolableObjectFactory}. A non-null factory must be provided either as a constructor argument or via a call to {@link #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 GenericKeyedObjectPool @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
org.apache.commons.pool2.impl.GenericObjectPool
A configurable {@link ObjectPool} implementation.
When coupled with the appropriate {@link PooledObjectFactory}, GenericObjectPool provides robust pooling functionality for arbitrary objects.

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 are available. This is performed by an "idle object eviction" thread, which runs asynchronously. Caution should be used when configuring this optional feature. Eviction runs contend with client threads for access to objects in the pool, so if they run too frequently performance issues may result.

The pool can also be configured to detect and remove "abandoned" objects, i.e. objects that have been checked out of the pool but neither used nor returned before the configured {@link AbandonedConfig#getRemoveAbandonedTimeout() removeAbandonedTimeout}. Abandoned object removal can be configured to happen when borrowObject is invoked and the pool is close to starvation, or it can be executed by the idle object evictor, or both. If pooled objects implement the {@link TrackedUse} interface, their last use will be queriedusing the getLastUsed method on that interface; otherwise abandonment is determined by how long an object has been checked out from the pool.

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.

This class is intended to be thread-safe.
@see GenericKeyedObjectPool @param < T> Type of element pooled in this pool. @version $Revision: 1537359 $ @since 2.0
org.apache.tomcat.dbcp.pool.impl.GenericObjectPool
org.datanucleus.store.rdbms.datasource.dbcp.pool.impl.GenericObjectPool
A configurable {@link ObjectPool} implementation.
When coupled with the appropriate {@link PoolableObjectFactory}, GenericObjectPool provides robust pooling functionality for arbitrary objects.
A GenericObjectPool provides a number of configurable parameters:
- {@link #setMaxActive maxActive} controls the maximum number ofobjects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. When non-positive, there is no limit to the number of objects that can be managed by the pool at one time. When {@link #setMaxActive maxActive} is reached, the pool is saidto be exhausted. The default setting for this parameter is 8.
- {@link #setMaxIdle maxIdle} controls the maximum number of objectsthat can sit idle in the pool at any time. When negative, there is no limit to the number of objects that may be idle at one time. The default setting for this parameter is 8.
- {@link #setWhenExhaustedAction whenExhaustedAction} specifies thebehavior of the {@link #borrowObject} method when the pool is exhausted:
  - When {@link #setWhenExhaustedAction whenExhaustedAction} is{@link #WHEN_EXHAUSTED_FAIL}, {@link #borrowObject} will throwa {@link NoSuchElementException}
  - When {@link #setWhenExhaustedAction whenExhaustedAction} is{@link #WHEN_EXHAUSTED_GROW}, {@link #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} will block(invoke {@link Object#wait()}) until a new or idle object is available. If a positive {@link #setMaxWait maxWait}value is supplied, then {@link #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} method will block indefinitely.
  The default whenExhaustedAction setting is {@link #WHEN_EXHAUSTED_BLOCK} and the default maxWaitsetting is -1. By default, therefore, borrowObject will block indefinitely until an idle instance becomes available.
- When {@link #setTestOnBorrow testOnBorrow} is set, the pool willattempt to validate each object before it is returned from the {@link #borrowObject} method. (Using the provided factory's{@link PoolableObjectFactory#validateObject} method.) Objects that failto 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} method. (Using the provided factory's{@link PoolableObjectFactory#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 are available. This is performed by an "idle object eviction" thread, which runs asynchronously. Caution should be used when configuring this optional feature. Eviction runs contend with client threads for access to objects in the pool, so if they run too frequently 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., idle object eviction is disabled by default).
- {@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 PoolableObjectFactory#validateObject} method. Objects that fail tovalidate will be dropped from the pool. This setting has no effect unless timeBetweenEvictionRunsMillis > 0. The default setting for this parameter is false.
- {@link #setSoftMinEvictableIdleTimeMillis softMinEvictableIdleTimeMillis}specifies the minimum amount of time an object may sit idle in the pool before it is eligible for eviction by the idle object evictor (if any), with the extra condition that at least "minIdle" object instances remain in the pool. When non-positive, no objects will be evicted from the pool due to idle time alone. This setting has no effect unless timeBetweenEvictionRunsMillis > 0. and it is superceded by {@link #setMinEvictableIdleTimeMillis minEvictableIdleTimeMillis}(that is, if minEvictableIdleTimeMillis is positive, then softMinEvictableIdleTimeMillis is ignored). The default setting for this parameter is -1 (disabled).
- {@link #setNumTestsPerEvictionRun numTestsPerEvictionRun}determines the number of objects examined in each run of the idle object evictor. This setting has no effect unless timeBetweenEvictionRunsMillis > 0. The default setting for this parameter is 3.
The pool can be configured to behave as a LIFO queue with respect to idle objects - always returning the most recently used object from the pool, or as a FIFO queue, where borrowObject always returns the oldest object in the idle object pool.
- {@link #setLifo lifo}determines whether or not the pool returns idle objects in last-in-first-out order. The default setting for this parameter is true.
GenericObjectPool is not usable without a {@link PoolableObjectFactory}. A non-null factory must be provided either as a constructor argument or via a call to {@link #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 GenericKeyedObjectPool @author Rodney Waldhoff @author Dirk Verbeeck @author Sandy McArthur @version $Revision: 952050 $ $Date: 2010-06-06 21:15:50 -0400 (Sun, 06 Jun 2010) $ @since Pool 1.0

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

    private URIResolver uriResolver;


    public XsltTransformer()
    {
        super();
        transformerPool = new GenericObjectPool(new PooledXsltTransformerFactory());
        transformerPool.setMinIdle(MIN_IDLE_TRANSFORMERS);
        transformerPool.setMaxIdle(MAX_IDLE_TRANSFORMERS);
        transformerPool.setMaxActive(MAX_ACTIVE_TRANSFORMERS);
        uriResolver = new LocalURIResolver();
        contextProperties = new HashMap();

View Full Code Here

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

        }
    }


    protected synchronized ObjectPool getClientPool(ImmutableEndpoint endpoint)
    {
        GenericObjectPool pool = pools.get(endpoint.getEndpointURI());


        if (pool == null)
        {
            if (logger.isDebugEnabled())
            {
                logger.debug("Pool is null - creating one for endpoint " + endpoint.getEndpointURI()
                             + " with max size " + getMaxConnectionPoolSize());
            }
            pool = new GenericObjectPool(new SftpConnectionFactory(endpoint), getMaxConnectionPoolSize());
            pool.setTestOnBorrow(isValidateConnections());
            pools.put(endpoint.getEndpointURI(), pool);
        }
        else
        {
            if (logger.isDebugEnabled())
            {
                logger.debug("Using existing pool for endpoint " + endpoint.getEndpointURI() + ". Active: "
                             + pool.getNumActive() + ", Idle:" + pool.getNumIdle());
            }
        }


        return pool;
    }

View Full Code Here

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

    {
        FtpConnector c = (FtpConnector)muleContext.getRegistry().lookupConnector("receiverFtpConnector");
        assertNotNull(c);
        
        MuleEndpointURI uri = new MuleEndpointURI("http://localhost", null);
        GenericObjectPool objectPool = (GenericObjectPool) c.getFtpPool(uri);
        assertEquals(GenericObjectPool.WHEN_EXHAUSTED_FAIL, objectPool.getWhenExhaustedAction());
    }

View Full Code Here

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

            try
            {
                FtpConnectionFactory connectionFactory =
                        (FtpConnectionFactory) ClassUtils.instanciateClass(getConnectionFactoryClass(),
                                                                            new Object[] {uri}, getClass());
                GenericObjectPool genericPool = createPool(connectionFactory);
                pools.put(key, genericPool);
                pool = genericPool;
            }
            catch (Exception ex)
            {

View Full Code Here

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

        return pool;
    }


    protected GenericObjectPool createPool(FtpConnectionFactory connectionFactory)
    {
        GenericObjectPool genericPool = new GenericObjectPool(connectionFactory);
        byte poolExhaustedAction = ThreadingProfile.DEFAULT_POOL_EXHAUST_ACTION;


        ThreadingProfile receiverThreadingProfile = this.getReceiverThreadingProfile();
        if (receiverThreadingProfile != null)
        {
            int threadingProfilePoolExhaustedAction = receiverThreadingProfile.getPoolExhaustedAction();
            if (threadingProfilePoolExhaustedAction == ThreadingProfile.WHEN_EXHAUSTED_WAIT)
            {
                poolExhaustedAction = GenericObjectPool.WHEN_EXHAUSTED_BLOCK;
            }
            else if (threadingProfilePoolExhaustedAction == ThreadingProfile.WHEN_EXHAUSTED_ABORT)
            {
                poolExhaustedAction = GenericObjectPool.WHEN_EXHAUSTED_FAIL;
            }
            else if (threadingProfilePoolExhaustedAction == ThreadingProfile.WHEN_EXHAUSTED_RUN)
            {
                poolExhaustedAction = GenericObjectPool.WHEN_EXHAUSTED_GROW;
            }
        }


        genericPool.setWhenExhaustedAction(poolExhaustedAction);
        genericPool.setTestOnBorrow(isValidateConnections());
        return genericPool;
    }

View Full Code Here

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

        ConnectionFactory connectionFactory)
    {
        ObjectPool connectionPool = mapConnectKeyToPool.get(key);
        if (connectionPool == null) {
            // use GenericObjectPool, which provides for resource limits
            connectionPool = new GenericObjectPool(
                null, // PoolableObjectFactory, can be null
                50, // max active
                GenericObjectPool.WHEN_EXHAUSTED_BLOCK, // action when exhausted
                3000, // max wait (milli seconds)
                10, // max idle

View Full Code Here

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

    
    // Create RemoteDelivery object factory used in pool
    GenericPoolableRemoteDeliveryFactory remoteDeliveryObjectFactory = new GenericPoolableRemoteDeliveryFactory();
    
    // Create pool
    remoteDeliveryObjectPool = new GenericObjectPool(
        remoteDeliveryObjectFactory,
        gopConf
    );
    
    // Initialize object factory of pool

View Full Code Here

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

    Properties jdbcProps = repoContext.getConnectionProperties();


    ConnectionFactory connFactory =
        new DriverManagerConnectionFactory(connectUrl, jdbcProps);


    connectionPool = new GenericObjectPool();
    connectionPool.setMaxActive(repoContext.getMaximumConnections());


    statementPool = new GenericKeyedObjectPoolFactory(null);


    // creating the factor automatically wires the connection pool

View Full Code Here

Examples of org.apache.commons.pool2.impl.GenericObjectPool

    this.address = address;
    this.connectionInfo = connectionInfo;
    JedisFactory factory = new JedisFactory(address.getHost(), address.getPort(), connectionInfo.getTimeout(),
        connectionInfo.getPassword(), connectionInfo.getDatabase());


    internalPool = new GenericObjectPool(factory, config);
  }

View Full Code Here

Examples of org.apache.tomcat.dbcp.pool.impl.GenericObjectPool

    // actual pool of connections.
    //
    // We'll use a GenericObjectPool instance, although
    // any ObjectPool implementation will suffice.
    //
    GenericObjectPool connectionPool = new GenericObjectPool(null);


    connectionPool.setMinIdle(minIdle);
    connectionPool.setMaxActive(maxActive);


    ConnectionManager._pool = connectionPool;
    // we keep it for two reasons
    // #1 We need it for statistics/debugging
    // #2 PoolingDataSource does not have getPool()

View Full Code Here

0 1 2 3 4 5

TOP

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.