Example usage for org.apache.commons.pool2.impl GenericObjectPool returnObject

Introduction

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

Prototype

@Override
public void returnObject(T obj) 

Source Link

Document

If #getMaxIdle() maxIdle is set to a positive value and the number of idle instances has reached this value, the returning instance is destroyed.

Usage

From source file:me.smoe.adar.pool.commonpool.CommonPool.java

public static void main(String[] args) throws NoSuchElementException, IllegalStateException, Exception {
    GenericObjectPool<Book> objectPool = new GenericObjectPool<Book>(new BookPoolFactory(),
            buildPoolConfig(5, 10, 2));//from   ww  w  . j a  va2  s .c  om
    prestartCorePool(objectPool);

    List<Book> books = new LinkedList<Book>();
    for (int i = 0; i < 10; i++) {
        books.add(objectPool.borrowObject());
    }

    for (Book book : books) {
        objectPool.returnObject(book);
    }
}

---

From source file:com.heliosapm.streams.collector.ds.pool.TestMQPool.java

/**
 * @param args/*from   www  . ja va2 s  . co m*/
 */
public static void main(String[] args) {
    try {
        log("Pool Test");
        log(TEST_PROPS);
        JMXHelper.fireUpJMXMPServer(1077);
        final Properties p = Props.strToProps(TEST_PROPS);
        log("Props:" + p);
        final GenericObjectPool<Object> pool = null;//(GenericObjectPool<Object>)PoolConfig.deployPool(p);
        pool.preparePool();
        log("Pool Deployed:" + pool.getNumIdle());
        final List<Object> objects = new ArrayList<Object>();
        for (int i = 0; i < 4; i++) {
            try {
                final Object o = pool.borrowObject();
                log("Borrowed:" + o);
                objects.add(o);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        log("Objects:" + objects.size());
        StdInCommandHandler.getInstance().registerCommand("close", new Runnable() {
            public void run() {
                for (Object o : objects) {
                    pool.returnObject(o);
                }
                objects.clear();
                try {
                    pool.close();
                } catch (Exception ex) {
                    ex.printStackTrace(System.err);
                }
            }
        }).run();
    } catch (Exception ex) {
        ex.printStackTrace(System.err);
    }

}

---

From source file:com.lambdaworks.redis.support.ConnectionPoolSupportTest.java

@Test
public void genericPoolShouldWorkWithWrappedConnections() throws Exception {

    GenericObjectPool<StatefulRedisConnection<String, String>> pool = ConnectionPoolSupport
            .createGenericObjectPool(() -> client.connect(), new GenericObjectPoolConfig());

    borrowAndReturn(pool);/*from   w  ww  . j  a  va 2s.c o  m*/
    borrowAndClose(pool);
    borrowAndCloseTryWithResources(pool);

    pool.returnObject(pool.borrowObject().sync().getStatefulConnection());
    pool.returnObject(pool.borrowObject().async().getStatefulConnection());

    pool.close();
}

---

From source file:com.lambdaworks.redis.support.ConnectionPoolSupportTest.java

@Test
public void softReferencePoolShouldWorkWithWrappedConnections() throws Exception {

    GenericObjectPool<StatefulRedisConnection<String, String>> pool = ConnectionPoolSupport
            .createGenericObjectPool(() -> client.connect(), new GenericObjectPoolConfig());

    borrowAndReturn(pool);/*ww w  . ja  va2  s.  c  o m*/
    borrowAndClose(pool);
    borrowAndCloseTryWithResources(pool);

    pool.returnObject(pool.borrowObject().sync().getStatefulConnection());
    pool.returnObject(pool.borrowObject().async().getStatefulConnection());

    pool.close();
}

---

From source file:io.lettuce.core.support.ConnectionPoolSupportTest.java

@Test
public void genericPoolShouldWorkWithWrappedConnections() throws Exception {

    GenericObjectPool<StatefulRedisConnection<String, String>> pool = ConnectionPoolSupport
            .createGenericObjectPool(() -> client.connect(), new GenericObjectPoolConfig());

    borrowAndReturn(pool);/*  w  w  w . ja  va  2  s  .c om*/
    borrowAndClose(pool);
    borrowAndCloseTryWithResources(pool);

    pool.returnObject(pool.borrowObject().sync().getStatefulConnection());
    pool.returnObject(pool.borrowObject().async().getStatefulConnection());

    assertThat(channels).hasSize(1);

    pool.close();

    Wait.untilTrue(channels::isEmpty).waitOrTimeout();

    assertThat(channels).isEmpty();
}

---

From source file:com.lambdaworks.redis.support.ConnectionPoolSupportTest.java

@Test
public void genericPoolShouldWorkWithPlainConnections() throws Exception {

    GenericObjectPool<StatefulRedisConnection<String, String>> pool = ConnectionPoolSupport
            .createGenericObjectPool(() -> client.connect(), new GenericObjectPoolConfig(), false);

    borrowAndReturn(pool);/*w  ww .ja v  a2s  .  c  o  m*/

    StatefulRedisConnection<String, String> connection = pool.borrowObject();
    assertThat(Proxy.isProxyClass(connection.getClass())).isFalse();
    pool.returnObject(connection);

    pool.close();
}

---

From source file:io.lettuce.core.support.ConnectionPoolSupportTest.java

@Test
public void genericPoolShouldCloseConnectionsAboveMaxIdleSize() throws Exception {

    GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
    poolConfig.setMaxIdle(2);//w  w w . j  ava  2s.  c  om

    GenericObjectPool<StatefulRedisConnection<String, String>> pool = ConnectionPoolSupport
            .createGenericObjectPool(() -> client.connect(), poolConfig);

    borrowAndReturn(pool);
    borrowAndClose(pool);
    borrowAndCloseTryWithResources(pool);

    StatefulRedisConnection<String, String> c1 = pool.borrowObject();
    StatefulRedisConnection<String, String> c2 = pool.borrowObject();
    StatefulRedisConnection<String, String> c3 = pool.borrowObject();

    assertThat(channels).hasSize(3);

    pool.returnObject(c1);
    pool.returnObject(c2);
    pool.returnObject(c3);

    assertThat(channels).hasSize(2);

    pool.close();

    Wait.untilTrue(channels::isEmpty).waitOrTimeout();

    assertThat(channels).isEmpty();
}

---

From source file:com.adaptris.core.services.splitter.ServiceWorkerPool.java

public void warmup(final GenericObjectPool<Worker> objectPool) throws CoreException {
    ExecutorService populator = Executors
            .newCachedThreadPool(new ManagedThreadFactory(this.getClass().getSimpleName()));
    try {//from w w w .jav  a2  s  .com
        log.trace("Warming up {} service-workers", maxThreads);
        final List<Future<Worker>> futures = new ArrayList<>(maxThreads);

        for (int i = 0; i < maxThreads; i++) {
            futures.add(populator.submit(new Callable<Worker>() {

                @Override
                public Worker call() throws Exception {
                    return objectPool.borrowObject();
                }

            }));
        }
        for (Worker w : waitFor(futures)) {
            objectPool.returnObject(w);
        }
        log.trace("ObjectPool contains {} (active) of {} objects", objectPool.getNumActive(),
                objectPool.getNumIdle());
    } catch (Exception e) {
        throw ExceptionHelper.wrapCoreException(e);
    } finally {
        populator.shutdownNow();
    }
}

---

From source file:com.adaptris.core.services.splitter.ServiceWorkerPool.java

/**
 * /*w  w  w  .  java 2s  .c  o m*/
 * @deprecated since 3.8.3 switch to commons-pool2 instead.
 */
@Deprecated
@Removal(version = "3.9.0", message = "use commons-pool2 variant instead")
public void warmup(final org.apache.commons.pool.impl.GenericObjectPool<Worker> objectPool)
        throws CoreException {
    logDeprecationWarning();
    ExecutorService populator = Executors
            .newCachedThreadPool(new ManagedThreadFactory(this.getClass().getSimpleName()));
    try {
        log.trace("Warming up {} service-workers", maxThreads);
        final List<Future<Worker>> futures = new ArrayList<>(maxThreads);

        for (int i = 0; i < maxThreads; i++) {
            futures.add(populator.submit(new Callable<Worker>() {

                @Override
                public Worker call() throws Exception {
                    return objectPool.borrowObject();
                }

            }));
        }
        for (Worker w : waitFor(futures)) {
            objectPool.returnObject(w);
        }
        log.trace("ObjectPool contains {} (active) of {} objects", objectPool.getNumActive(),
                objectPool.getNumIdle());

    } catch (Exception e) {
        throw ExceptionHelper.wrapCoreException(e);
    } finally {
        populator.shutdownNow();
    }
}

---

From source file:com.lambdaworks.redis.support.ConnectionPoolSupportTest.java

@Test
public void plainConnectionShouldNotUseWrappers() throws Exception {

    GenericObjectPool<StatefulRedisConnection<String, String>> pool = ConnectionPoolSupport
            .createGenericObjectPool(() -> client.connect(), new GenericObjectPoolConfig(), false);

    StatefulRedisConnection<String, String> connection = pool.borrowObject();
    RedisCommands<String, String> sync = connection.sync();

    assertThat(connection).isInstanceOf(StatefulRedisConnection.class)
            .isNotInstanceOf(StatefulRedisClusterConnectionImpl.class);
    assertThat(Proxy.isProxyClass(connection.getClass())).isFalse();

    assertThat(sync).isInstanceOf(RedisCommands.class);
    assertThat(connection.async()).isInstanceOf(RedisAsyncCommands.class)
            .isInstanceOf(RedisAsyncCommandsImpl.class);
    assertThat(connection.reactive()).isInstanceOf(RedisReactiveCommands.class)
            .isInstanceOf(RedisReactiveCommandsImpl.class);
    assertThat(sync.getStatefulConnection()).isInstanceOf(StatefulRedisConnection.class)
            .isInstanceOf(StatefulRedisConnectionImpl.class);

    pool.returnObject(connection);
    pool.close();/*from  w  ww  . j a v a  2  s  .  c o m*/
}

---

• «
• 1
• 2
• »