Java Code Examples for org.apache.commons.pool2.impl.GenericKeyedObjectPoolConfig#setMaxTotal()

@Test
public void test() {
    PooledConnectionFactory pooledConnectionFactory = new PooledConnectionFactory(500, 500);

    GenericKeyedObjectPoolConfig conf = new GenericKeyedObjectPoolConfig();
    conf.setMaxTotal(20);
    ConnectionPool connectionPool = new ConnectionPool(pooledConnectionFactory, conf);

    Set<String> trackerSet = new HashSet<String>();
    trackerSet.add("192.168.10.128:22122");

    DefaultCommandExecutor connectionManager = new DefaultCommandExecutor(trackerSet, connectionPool);

    connectionManager.dumpPoolInfo();

    GetStorageNodeCommand command = new GetStorageNodeCommand();
    StorageNode storageNode = connectionManager.execute(command);
    logger.info(storageNode.toString());

    connectionManager.dumpPoolInfo();

    connectionPool.close();
}
 

private GenericKeyedObjectPool<PreparedContextKey, PreparedContext> createPreparedContextPool() {
    PreparedContextFactory factory = new PreparedContextFactory();
    KylinConfig kylinConfig = getConfig();
    GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig();
    config.setMaxTotalPerKey(kylinConfig.getQueryMaxCacheStatementInstancePerKey());
    config.setMaxTotal(kylinConfig.getQueryMaxCacheStatementNum());
    config.setBlockWhenExhausted(false);
    config.setMinEvictableIdleTimeMillis(10 * 60 * 1000L); // cached statement will be evict if idle for 10 minutes
    config.setTimeBetweenEvictionRunsMillis(60 * 1000L); 
    GenericKeyedObjectPool<PreparedContextKey, PreparedContext> pool = new GenericKeyedObjectPool<>(factory,
            config);
    return pool;
}
 

public void init() {
    debug = conf.getBoolean("literpc.endpoint.tcp.debug", false);
    GenericKeyedObjectPoolConfig poolConfig = new GenericKeyedObjectPoolConfig();
    poolConfig.setMaxTotal(500);
    poolConfig.setTestWhileIdle(true);
    pool = new GenericKeyedObjectPool<>(new RpcSocketFactory(), poolConfig);
}
 

@Test
public void test03() throws InterruptedException {
    PooledConnectionFactory pooledConnectionFactory = new PooledConnectionFactory(5000, 5000);

    GenericKeyedObjectPoolConfig conf = new GenericKeyedObjectPoolConfig();
    conf.setMaxTotal(200);
    conf.setMaxTotalPerKey(200);
    conf.setMaxIdlePerKey(100);
    ConnectionPool connectionPool = new ConnectionPool(pooledConnectionFactory, conf);

    Set<String> trackerSet = new HashSet<String>();
    trackerSet.add("192.168.10.128:22122");

    DefaultCommandExecutor connectionManager = new DefaultCommandExecutor(trackerSet, connectionPool);

    for (int i = 0; i <= 50; i++) {
        Thread thread = new PoolTest(connectionManager);
        thread.start();
    }

    for (int i = 0; i <= 2; i++) {
        connectionManager.dumpPoolInfo();
        Thread.sleep(1000 * 2);
    }

    connectionPool.close();
}
 

@Before
public void init() {
    PooledConnectionFactory pooledConnectionFactory = new PooledConnectionFactory(500, 500);
    GenericKeyedObjectPoolConfig conf = new GenericKeyedObjectPoolConfig();
    conf.setMaxTotal(200);
    conf.setMaxTotalPerKey(200);
    conf.setMaxIdlePerKey(100);
    connectionPool = new ConnectionPool(pooledConnectionFactory, conf);
    Set<String> trackerSet = new HashSet<String>();
    trackerSet.add("192.168.10.128:22122");
    DefaultCommandExecutor commandExecutor = new DefaultCommandExecutor(trackerSet, connectionPool);
    trackerClient = new DefaultTrackerClient(commandExecutor);
}
 

@Before
public void init() {
    PooledConnectionFactory pooledConnectionFactory = new PooledConnectionFactory(500, 500);
    GenericKeyedObjectPoolConfig conf = new GenericKeyedObjectPoolConfig();
    conf.setMaxTotal(200);
    conf.setMaxTotalPerKey(200);
    conf.setMaxIdlePerKey(100);
    connectionPool = new ConnectionPool(pooledConnectionFactory, conf);
    Set<String> trackerSet = new HashSet<String>();
    trackerSet.add("192.168.10.128:22122");
    DefaultCommandExecutor commandExecutor = new DefaultCommandExecutor(trackerSet, connectionPool);
    TrackerClient trackerClient = new DefaultTrackerClient(commandExecutor);
    storageClient = new DefaultStorageClient(commandExecutor, trackerClient);
}
 

@Bean
@ConditionalOnMissingBean(name = "thriftClientsPool")
public KeyedObjectPool<ThriftClientKey, TServiceClient> thriftClientsPool() {
    GenericKeyedObjectPoolConfig poolConfig = new GenericKeyedObjectPoolConfig();
    poolConfig.setMaxTotal(maxTotalThreads);
    poolConfig.setMaxIdlePerKey(maxIdleThreads);
    poolConfig.setMaxTotalPerKey(maxThreads);
    poolConfig.setJmxEnabled(false); //cause spring will autodetect itself
    return new ThriftClientPool(thriftClientPoolFactory(), poolConfig);
}
 

private GenericKeyedObjectPool<PreparedContextKey, PreparedContext> createPreparedContextPool() {
    PreparedContextFactory factory = new PreparedContextFactory();
    KylinConfig kylinConfig = getConfig();
    GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig();
    config.setMaxTotalPerKey(kylinConfig.getQueryMaxCacheStatementInstancePerKey());
    config.setMaxTotal(kylinConfig.getQueryMaxCacheStatementNum());
    config.setBlockWhenExhausted(false);
    config.setMinEvictableIdleTimeMillis(10 * 60 * 1000L); // cached statement will be evict if idle for 10 minutes
    config.setTimeBetweenEvictionRunsMillis(60 * 1000L); 
    GenericKeyedObjectPool<PreparedContextKey, PreparedContext> pool = new GenericKeyedObjectPool<>(factory,
            config);
    return pool;
}
 

@Before
public void setUp() {
    final GenericKeyedObjectPoolConfig<TestObject> config = new GenericKeyedObjectPoolConfig<>();
    config.setMaxTotal(3);

    final KeyedPooledObjectFactory<String, TestObject> factory =
            new TestKeyedObjectFactory();

    @SuppressWarnings("resource")
    final KeyedObjectPool<String, TestObject> innerPool =
            new GenericKeyedObjectPool<>(
                    factory, config);

    pool = new ProxiedKeyedObjectPool<>(innerPool, getproxySource());
}
 

private void registerPool(final String userName, final String password) throws NamingException, SQLException {

        final ConnectionPoolDataSource cpds = testCPDS(userName, password);

        // Create an object pool to contain our PooledConnections
        factory = new KeyedCPDSConnectionFactory(cpds, getValidationQuery(), getValidationQueryTimeout(),
                isRollbackAfterValidation());
        factory.setMaxConnLifetimeMillis(getMaxConnLifetimeMillis());

        final GenericKeyedObjectPoolConfig<PooledConnectionAndInfo> config = new GenericKeyedObjectPoolConfig<>();
        config.setBlockWhenExhausted(getDefaultBlockWhenExhausted());
        config.setEvictionPolicyClassName(getDefaultEvictionPolicyClassName());
        config.setLifo(getDefaultLifo());
        config.setMaxIdlePerKey(getDefaultMaxIdle());
        config.setMaxTotal(getMaxTotal());
        config.setMaxTotalPerKey(getDefaultMaxTotal());
        config.setMaxWaitMillis(getDefaultMaxWaitMillis());
        config.setMinEvictableIdleTimeMillis(getDefaultMinEvictableIdleTimeMillis());
        config.setMinIdlePerKey(getDefaultMinIdle());
        config.setNumTestsPerEvictionRun(getDefaultNumTestsPerEvictionRun());
        config.setSoftMinEvictableIdleTimeMillis(getDefaultSoftMinEvictableIdleTimeMillis());
        config.setTestOnCreate(getDefaultTestOnCreate());
        config.setTestOnBorrow(getDefaultTestOnBorrow());
        config.setTestOnReturn(getDefaultTestOnReturn());
        config.setTestWhileIdle(getDefaultTestWhileIdle());
        config.setTimeBetweenEvictionRunsMillis(getDefaultTimeBetweenEvictionRunsMillis());

        final KeyedObjectPool<UserPassKey, PooledConnectionAndInfo> tmpPool = new GenericKeyedObjectPool<>(factory,
                config);
        factory.setPool(tmpPool);
        pool = tmpPool;
    }
 

/**
 * Uses the configured XAConnectionFactory to create a {@link PoolableManagedConnection}. Throws
 * <code>IllegalStateException</code> if the connection factory returns null. Also initializes the connection using
 * configured initialization SQL (if provided) and sets up a prepared statement pool associated with the
 * PoolableManagedConnection if statement pooling is enabled.
 */
@Override
public synchronized PooledObject<PoolableConnection> makeObject() throws Exception {
    Connection conn = getConnectionFactory().createConnection();
    if (conn == null) {
        throw new IllegalStateException("Connection factory returned null from createConnection");
    }
    initializeConnection(conn);
    if (getPoolStatements()) {
        conn = new PoolingConnection(conn);
        final GenericKeyedObjectPoolConfig<DelegatingPreparedStatement> config = new GenericKeyedObjectPoolConfig<>();
        config.setMaxTotalPerKey(-1);
        config.setBlockWhenExhausted(false);
        config.setMaxWaitMillis(0);
        config.setMaxIdlePerKey(1);
        config.setMaxTotal(getMaxOpenPreparedStatements());
        final ObjectName dataSourceJmxName = getDataSourceJmxName();
        final long connIndex = getConnectionIndex().getAndIncrement();
        if (dataSourceJmxName != null) {
            final StringBuilder base = new StringBuilder(dataSourceJmxName.toString());
            base.append(Constants.JMX_CONNECTION_BASE_EXT);
            base.append(Long.toString(connIndex));
            config.setJmxNameBase(base.toString());
            config.setJmxNamePrefix(Constants.JMX_STATEMENT_POOL_PREFIX);
        } else {
            config.setJmxEnabled(false);
        }
        final KeyedObjectPool<PStmtKey, DelegatingPreparedStatement> stmtPool = new GenericKeyedObjectPool<>(
                (PoolingConnection) conn, config);
        ((PoolingConnection) conn).setStatementPool(stmtPool);
        ((PoolingConnection) conn).setCacheState(getCacheState());
    }
    final PoolableManagedConnection pmc = new PoolableManagedConnection(transactionRegistry, conn, getPool(),
            getDisconnectionSqlCodes(), isFastFailValidation());
    pmc.setCacheState(getCacheState());
    return new DefaultPooledObject<>(pmc);
}
 

@BeforeEach
public void setUp() throws Exception {
    con = new PoolingConnection(new TesterConnection("test", "test"));
    final GenericKeyedObjectPoolConfig<DelegatingPreparedStatement> config = new GenericKeyedObjectPoolConfig<>();
    config.setMaxTotalPerKey(-1);
    config.setBlockWhenExhausted(false);
    config.setMaxWaitMillis(0);
    config.setMaxIdlePerKey(1);
    config.setMaxTotal(1);
    final KeyedObjectPool<PStmtKey, DelegatingPreparedStatement> stmtPool =
            new GenericKeyedObjectPool<>(con, config);
    con.setStatementPool(stmtPool);
}
 

private GenericKeyedObjectPoolConfig getConfig(PoolConfig poolConfig) {
	GenericKeyedObjectPoolConfig objectPoolConfig = new GenericKeyedObjectPoolConfig();

	objectPoolConfig.setMaxTotalPerKey(poolConfig.getMaxTotalPerKey());
	objectPoolConfig.setMaxTotal(poolConfig.getMaxTotal());

	objectPoolConfig.setMaxIdlePerKey(poolConfig.getMaxIdlePerKey());
	objectPoolConfig.setMinIdlePerKey(poolConfig.getMinIdlePerKey());

	objectPoolConfig.setTestWhileIdle(poolConfig.isTestWhileIdle());
	objectPoolConfig.setTestOnReturn(poolConfig.isTestOnReturn());
	objectPoolConfig.setTestOnCreate(poolConfig.isTestOnCreate());
	objectPoolConfig.setTestOnBorrow(poolConfig.isTestOnBorrow());

	objectPoolConfig.setTimeBetweenEvictionRunsMillis(poolConfig.getTimeBetweenEvictionRunsMillis());
	objectPoolConfig.setEvictionPolicyClassName(poolConfig.getEvictionPolicyClassName());
	objectPoolConfig.setMinEvictableIdleTimeMillis(poolConfig.getMinEvictableIdleTimeMillis());
	objectPoolConfig.setNumTestsPerEvictionRun(poolConfig.getNumTestsPerEvictionRun());
	objectPoolConfig.setSoftMinEvictableIdleTimeMillis(poolConfig.getSoftMinEvictableIdleTimeMillis());

	objectPoolConfig.setJmxEnabled(poolConfig.isJmxEnabled());
	objectPoolConfig.setJmxNameBase(poolConfig.getJmxNameBase());
	objectPoolConfig.setJmxNamePrefix(poolConfig.getJmxNamePrefix());

	objectPoolConfig.setMaxWaitMillis(poolConfig.getMaxWaitMillis());

	objectPoolConfig.setFairness(poolConfig.isFairness());
	objectPoolConfig.setBlockWhenExhausted(poolConfig.isBlockWhenExhausted());
	objectPoolConfig.setLifo(poolConfig.isLifo());

	return objectPoolConfig;
}
 

private void run() throws Exception {
    final GenericKeyedObjectPoolConfig poolConfig = new GenericKeyedObjectPoolConfig();
    poolConfig.setMaxTotal(10);
    poolConfig.setMaxTotalPerKey(5);
    poolConfig.setMinIdlePerKey(-1);
    poolConfig.setMaxIdlePerKey(-1);
    poolConfig.setLifo(true);
    poolConfig.setFairness(true);
    poolConfig.setMaxWaitMillis(30 * 1000);
    poolConfig.setMinEvictableIdleTimeMillis(-1);
    poolConfig.setSoftMinEvictableIdleTimeMillis(-1);
    poolConfig.setNumTestsPerEvictionRun(1);
    poolConfig.setTestOnCreate(false);
    poolConfig.setTestOnBorrow(false);
    poolConfig.setTestOnReturn(false);
    poolConfig.setTestWhileIdle(false);
    poolConfig.setTimeBetweenEvictionRunsMillis(5 * 1000);
    poolConfig.setEvictionPolicyClassName(BaseObjectPoolConfig.DEFAULT_EVICTION_POLICY_CLASS_NAME);
    poolConfig.setBlockWhenExhausted(false);
    poolConfig.setJmxEnabled(false);
    poolConfig.setJmxNameBase(null);
    poolConfig.setJmxNamePrefix(null);

    final GenericKeyedObjectPool<Integer, Object> pool = new GenericKeyedObjectPool<>(new ObjectFactory(), poolConfig);

    // number of threads to reproduce is finicky. this count seems to be best for my
    // 4 core box.
    // too many doesn't reproduce it ever, too few doesn't either.
    final ExecutorService service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2);
    final long startTime = System.currentTimeMillis();
    long testIter = 0;
    try {
        while (true) {
            testIter++;
            if (testIter % 1000 == 0) {
                System.out.println(testIter);
            }
            final List<Task> tasks = createTasks(pool);
            final List<Future<Object>> futures = service.invokeAll(tasks);
            for (final Future<Object> future : futures) {
                future.get();
            }
        }
    } finally {
        System.out.println("Time: " + (System.currentTimeMillis() - startTime) / 1000.0);
        service.shutdown();
    }
}
 

/**
 * Attempts to establish a database connection.
 *
 * @param pooledUserName
 *            name to be used for the connection
 * @param pooledUserPassword
 *            password to be used fur the connection
 */
@Override
public PooledConnection getPooledConnection(final String pooledUserName, final String pooledUserPassword)
        throws SQLException {
    getConnectionCalled = true;
    PooledConnectionImpl pooledConnection = null;
    // Workaround for buggy WebLogic 5.1 classloader - ignore the exception upon first invocation.
    try {
        if (connectionProperties != null) {
            update(connectionProperties, KEY_USER, pooledUserName);
            update(connectionProperties, KEY_PASSWORD, pooledUserPassword);
            pooledConnection = new PooledConnectionImpl(
                    DriverManager.getConnection(getUrl(), connectionProperties));
        } else {
            pooledConnection = new PooledConnectionImpl(
                    DriverManager.getConnection(getUrl(), pooledUserName, pooledUserPassword));
        }
        pooledConnection.setAccessToUnderlyingConnectionAllowed(isAccessToUnderlyingConnectionAllowed());
    } catch (final ClassCircularityError e) {
        if (connectionProperties != null) {
            pooledConnection = new PooledConnectionImpl(
                    DriverManager.getConnection(getUrl(), connectionProperties));
        } else {
            pooledConnection = new PooledConnectionImpl(
                    DriverManager.getConnection(getUrl(), pooledUserName, pooledUserPassword));
        }
        pooledConnection.setAccessToUnderlyingConnectionAllowed(isAccessToUnderlyingConnectionAllowed());
    }
    KeyedObjectPool<PStmtKey, DelegatingPreparedStatement> stmtPool = null;
    if (isPoolPreparedStatements()) {
        final GenericKeyedObjectPoolConfig<DelegatingPreparedStatement> config = new GenericKeyedObjectPoolConfig<>();
        config.setMaxTotalPerKey(Integer.MAX_VALUE);
        config.setBlockWhenExhausted(false);
        config.setMaxWaitMillis(0);
        config.setMaxIdlePerKey(getMaxIdle());
        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.
            config.setTimeBetweenEvictionRunsMillis(getTimeBetweenEvictionRunsMillis());
            config.setNumTestsPerEvictionRun(getNumTestsPerEvictionRun());
            config.setMinEvictableIdleTimeMillis(getMinEvictableIdleTimeMillis());
        } else {
            // since there is a 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.pool2.impl.GenericKeyedObjectPool.clearOldest method
            config.setMaxTotal(getMaxPreparedStatements());
            config.setTimeBetweenEvictionRunsMillis(-1);
            config.setNumTestsPerEvictionRun(0);
            config.setMinEvictableIdleTimeMillis(0);
        }
        stmtPool = new GenericKeyedObjectPool<>(pooledConnection, config);
        pooledConnection.setStatementPool(stmtPool);
    }
    return pooledConnection;
}