Example usage for org.apache.commons.pool2.impl GenericKeyedObjectPoolConfig setTestOnReturn

Introduction

In this page you can find the example usage for org.apache.commons.pool2.impl GenericKeyedObjectPoolConfig setTestOnReturn.

Prototype

public void setTestOnReturn(boolean testOnReturn)

Source Link

Document

Set the value for the testOnReturn configuration attribute for pools created with this configuration instance.

Usage

From source file:com.quancheng.saluki.core.grpc.GrpcEngine.java

private void initChannelPool() {
    GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig();
    config.setMaxTotal(1000);//from w  w w. j av a 2  s . co m
    config.setMaxTotalPerKey(3);
    config.setBlockWhenExhausted(true);
    config.setMinIdlePerKey(3);
    config.setMaxWaitMillis(10);
    config.setNumTestsPerEvictionRun(Integer.MAX_VALUE);
    config.setTestOnBorrow(false);
    config.setTestOnReturn(false);
    config.setTestWhileIdle(false);
    config.setTimeBetweenEvictionRunsMillis(1 * 60000L);
    config.setMinEvictableIdleTimeMillis(10 * 60000L);
    config.setTestWhileIdle(false);
    this.channelPool = new GenericKeyedObjectPool<GrpcURL, Channel>(new GrpcChannelFactory(), config);
}

From source file:com.google.devtools.build.lib.worker.WorkerModule.java

@Override
public void beforeCommand(Command command, CommandEnvironment env) {
    this.env = env;
    env.getEventBus().register(this);

    if (workers == null) {
        Path logDir = env.getRuntime().getOutputBase().getRelative("worker-logs");
        try {/*from   w  ww .jav a2s  .c o  m*/
            logDir.createDirectory();
        } catch (IOException e) {
            env.getReporter().handle(Event.error("Could not create directory for worker logs: " + logDir));
        }

        GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig();

        // It's better to re-use a worker as often as possible and keep it hot, in order to profit
        // from JIT optimizations as much as possible.
        config.setLifo(true);

        // Check for & deal with idle workers every 5 seconds.
        config.setTimeBetweenEvictionRunsMillis(5 * 1000);

        // Always test the liveliness of worker processes.
        config.setTestOnBorrow(true);
        config.setTestOnCreate(true);
        config.setTestOnReturn(true);
        config.setTestWhileIdle(true);

        // Don't limit the total number of worker processes, as otherwise the pool might be full of
        // e.g. Java workers and could never accommodate another request for a different kind of
        // worker.
        config.setMaxTotal(-1);

        workers = new WorkerPool(new WorkerFactory(), config);
        workers.setReporter(env.getReporter());
        workers.setLogDirectory(logDir);
    }
}

From source file:org.apache.sentry.core.common.transport.SentryTransportPool.java

/**
 * Configure transport pool.//from   ww w.  jav  a  2  s  . c  o  m
 * <p>
 * The pool accepts the following configuration:
 * <ul>
 *   <li>Maximum total number of objects in the pool</li>
 *   <li>Minimum number of idle objects</li>
 *   <li>Maximum number of idle objects</li>
 *   <li>Minimum time before the object is evicted</li>
 *   <li>Interval between evictions</li>
 * </ul>
 * @param conf Configuration
 * @param transportConfig Configuration interface
 * @param transportFactory Transport factory used to produce transports
 */
public SentryTransportPool(Configuration conf, SentryClientTransportConfigInterface transportConfig,
        TransportFactory transportFactory) {

    // This isn't thread-safe, but we don't care - it is only used
    // for debugging when running tests - normal apps use a single pool
    poolId++;
    id = poolId;

    this.transportFactory = transportFactory;
    doLoadBalancing = transportConfig.isLoadBalancingEnabled(conf);
    isPoolEnabled = transportConfig.isTransportPoolEnabled(conf);

    // Get list of server addresses
    String hostsAndPortsStr = transportConfig.getSentryServerRpcAddress(conf);
    int serverPort = transportConfig.getServerRpcPort(conf);
    LOGGER.info("Creating pool for {} with default port {}", hostsAndPortsStr, serverPort);
    String[] hostsAndPortsStrArr = hostsAndPortsStr.split(",");
    Preconditions.checkArgument(hostsAndPortsStrArr.length > 0, "At least one server should be specified");

    endpoints = new ArrayList<>(hostsAndPortsStrArr.length);
    for (String addr : hostsAndPortsStrArr) {
        HostAndPort endpoint = ThriftUtil.parseAddress(addr, serverPort);
        LOGGER.info("Adding endpoint {}", endpoint);
        endpoints.add(endpoint);
    }

    if (!isPoolEnabled) {
        pool = null;
        LOGGER.info("Connection pooling is disabled");
        return;
    }

    LOGGER.info("Connection pooling is enabled");
    // Set pool configuration based on Configuration settings
    GenericKeyedObjectPoolConfig poolConfig = new GenericKeyedObjectPoolConfig();

    // Don't limit maximum number of objects in the pool
    poolConfig.setMaxTotal(-1);

    poolConfig.setMinIdlePerKey(transportConfig.getPoolMinIdle(conf));
    poolConfig.setMaxIdlePerKey(transportConfig.getPoolMaxIdle(conf));

    // Do not block when pool is exhausted, throw exception instead
    poolConfig.setBlockWhenExhausted(false);
    poolConfig.setTestOnReturn(true);

    // No limit for total objects in the pool
    poolConfig.setMaxTotalPerKey(transportConfig.getPoolMaxTotal(conf));
    poolConfig.setMinEvictableIdleTimeMillis(transportConfig.getMinEvictableTimeSec(conf));
    poolConfig.setTimeBetweenEvictionRunsMillis(transportConfig.getTimeBetweenEvictionRunsSec(conf));

    // Create object pool
    pool = new GenericKeyedObjectPool<>(new PoolFactory(this.transportFactory, id), poolConfig);
}

From source file:org.springframework.ldap.pool2.factory.PooledContextSource.java

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;
}