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

                            return beanFactory.getBean(id);
                        }
                    };
                    //
                    // create a ObjectPool with PoolableObjectFactory created before
                    pool = new GenericObjectPool(pooleableFactory,
                            maxCapacity,
                            GenericObjectPool.WHEN_EXHAUSTED_BLOCK,
                            /*block indefinitely*/-1);
                }
            }

View Full Code Here

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

   * @return an empty Commons <code>ObjectPool</code>.
   * @see org.apache.commons.pool.impl.GenericObjectPool
   * @see #setMaxSize
   */
  protected ObjectPool createObjectPool() {
    GenericObjectPool gop = new GenericObjectPool(this);
    gop.setMaxActive(getMaxSize());
    gop.setMaxIdle(getMaxIdle());
    gop.setMinIdle(getMinIdle());
    gop.setMaxWait(getMaxWait());
    gop.setTimeBetweenEvictionRunsMillis(getTimeBetweenEvictionRunsMillis());
    gop.setMinEvictableIdleTimeMillis(getMinEvictableIdleTimeMillis());
    gop.setWhenExhaustedAction(getWhenExhaustedAction());
    return gop;
  }

View Full Code Here

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

                {
                    // logout and close object content manager and session
                    ((ObjectContentManagerImpl)obj).logout();
                }
            };
            ocmPool = new GenericObjectPool(sessionFactory, 0, GenericObjectPool.WHEN_EXHAUSTED_GROW, 0, 5);
            ocmPool.setTimeBetweenEvictionRunsMillis(60000);
            ocmPool.setMinEvictableIdleTimeMillis(300000);
            
            // initialize persistent store
            if (initializeStore)

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.pool.impl.GenericObjectPool

        try {
            Class.forName(driver);
        } catch (ClassNotFoundException ignore) {
        }


        GenericObjectPool connectionPool = new GenericObjectPool(null);
        ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(
                url, user, pass);
        PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(
                connectionFactory, connectionPool, null, null, false, true);

View Full Code Here

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

   * @throws Exception
   *             Error occurred when parsing properties to create the
   *             connection factory
   */
  private GenericObjectPool createGenericConnectionFactory(Config config) throws Exception {
    GenericObjectPool poolConnection = new GenericObjectPool();


    String maxPool = config.getProperty(RDBMS.MAX_POOL_SIZE);
    String maxIdle = config.getProperty(RDBMS.MAX_IDLE);
    String minPool = config.getProperty(RDBMS.MIN_POOL_SIZE);
    String maxWait = config.getProperty(RDBMS.MAX_WAIT);
    String testOnReturn = config.getProperty(RDBMS.TEST_ON_RETURN);
    String testOnBorrow = config.getProperty(RDBMS.TEST_ON_BORROW);
    String testWhileIdle = config.getProperty(RDBMS.TEST_WHILE_IDLE);
    String timeBetweenEvictionRunsMillis = config.getProperty(
        RDBMS.TIME_BETWEEN_EVICTION_RUNS_MILLS);
    String numTestsPerEvictionRun = config.getProperty(RDBMS.NUM_TESTS_PER_EVICTION_RUN);
    String minEvictableIdleTimeMillis = config.getProperty(
        RDBMS.MIN_EVICTABLE_IDLE_TIME_MILLIS);


    int minPoolSize = DBConstants.DEFAULT_DBCP_MIN_POOL_SIZE;
    int maxPoolSize = DBConstants.DEFAULT_DBCP_MAX_POOL_SIZE;
    try {
      if (!DBUtils.isEmptyString(maxPool)) {
        maxPoolSize = Integer.valueOf(maxPool).intValue();
        poolConnection.setMaxActive(maxPoolSize);
      }
      if (!DBUtils.isEmptyString(minPool)) {
        minPoolSize = Integer.valueOf(minPool).intValue();
        poolConnection.setMinIdle(minPoolSize);
      }
      int maxPoolIdle = poolConnection.getMaxIdle();
      if (!DBUtils.isEmptyString(maxIdle)) {
        maxPoolIdle = Integer.valueOf(maxIdle).intValue();
        poolConnection.setMaxIdle(maxPoolIdle);
      }
      if (!DBUtils.isEmptyString(maxWait)) {
        int maxPoolWait = Integer.valueOf(maxWait).intValue();
        poolConnection.setMaxWait(maxPoolWait);
      }
      if (!DBUtils.isEmptyString(testOnBorrow)) {
        poolConnection.setTestOnBorrow(Boolean.parseBoolean(testOnBorrow));
      }
      if (!DBUtils.isEmptyString(testOnReturn)) {
        poolConnection.setTestOnReturn(Boolean.parseBoolean(testOnReturn));
      }
      if (!DBUtils.isEmptyString(testWhileIdle)) {
        poolConnection.setTestWhileIdle(Boolean.parseBoolean(testWhileIdle));
      }
      if (!DBUtils.isEmptyString(timeBetweenEvictionRunsMillis)) {
        long timeBetweenPoolEvictionRunsMillis = Long
            .valueOf(timeBetweenEvictionRunsMillis).longValue();
        poolConnection.setTimeBetweenEvictionRunsMillis(timeBetweenPoolEvictionRunsMillis);
      }
      if (!DBUtils.isEmptyString(numTestsPerEvictionRun)) {
        int numTestsPerPoolEvictionRun = Integer.valueOf(numTestsPerEvictionRun).intValue();
        poolConnection.setNumTestsPerEvictionRun(numTestsPerPoolEvictionRun);
      }
      if (!DBUtils.isEmptyString(minEvictableIdleTimeMillis)) {
        long minPoolEvictableIdleTimeMillis = Long.valueOf(minEvictableIdleTimeMillis)
            .longValue();
        poolConnection.setMinEvictableIdleTimeMillis(minPoolEvictableIdleTimeMillis);
      }
      return poolConnection;
    } catch (NumberFormatException e) {
      log.error("Non-numeric value found for numeric pool configuration property", e);
      throw e;

View Full Code Here

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

     */
    public static ObjectPool createConnectionPool(String uri,
            Properties properties) {
        // Create an ObjectPool that will serve as the actual pool of
        // connections
        ObjectPool result = new GenericObjectPool(null);


        // Create a ConnectionFactory that the pool will use to create
        // Connections
        ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(
                uri, properties);

View Full Code Here

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

  private XAConnection connection;
  private ObjectPool sessionPool;


  public XASessionPool(final XAConnection connection)
  {
    this(connection, new GenericObjectPool(null, -1));
  }

View Full Code Here

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

            config.maxActive = poolingProfile.getMaxActive();
            config.maxWait = poolingProfile.getMaxWait();
            config.whenExhaustedAction = (byte) poolingProfile.getExhaustedAction();
        }


        pool = new GenericObjectPool(getPooledObjectFactory(), config);


        try
        {
            applyInitialisationPolicy();
        }

View Full Code Here

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

    protected Configuration configuration;


    public XQueryTransformer()
    {
        super();
        transformerPool = new GenericObjectPool(new PooledXQueryTransformerFactory());
        transformerPool.setMinIdle(MIN_IDLE_TRANSFORMERS);
        transformerPool.setMaxIdle(MAX_IDLE_TRANSFORMERS);
        transformerPool.setMaxActive(MAX_ACTIVE_TRANSFORMERS);


        registerSourceType(DataTypeFactory.STRING);

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.