Example usage for org.apache.commons.pool.impl GenericKeyedObjectPool returnObject

Introduction

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

Prototype

public void returnObject(Object key, Object obj) throws Exception 

Source Link

Document

Returns an object to a keyed pool.

For the pool to function correctly, the object instance must have been borrowed from the pool (under the same key) and not yet returned.

Usage

From source file:TestKeyedObjectPool.java

 public static void main(String args[]) throws Exception {

   GenericKeyedObjectPool pool = new GenericKeyedObjectPool();
   pool.setFactory(new SkilledEmployeeFactory());

   pool.addObject("Java");
   pool.addObject("Java");
   pool.addObject("VB");
   pool.addObject("C++");

   System.err.println("Number of Java employees in pool: " +
     pool.getNumIdle("Java") + " out of total employees: " +
     pool.getNumIdle());/*  w  w  w.  j a  va 2s.c  o  m*/

   Employee employee = (Employee)pool.borrowObject("Java");

   employee.doWork();

   System.err.println("Employee: "  + employee);

   pool.returnObject("Java", employee);

   System.err.println("Number of Java employees in pool: " +
     pool.getNumIdle("Java") + " out of total employees: " +
     pool.getNumIdle());
}

---

From source file:Pool146.java

public void testBlockedKeyDoesNotBlockPoolImproved() throws Exception {
    SimpleFactory factory = new SimpleFactory();
    GenericKeyedObjectPool pool = new GenericKeyedObjectPool(factory);
    pool.setWhenExhaustedAction(GenericKeyedObjectPool.WHEN_EXHAUSTED_BLOCK);
    pool.setMaxActive(1);//from   w  ww.  java  2s  . c  om
    pool.setMaxTotal(-1);

    // Borrow with one key
    Object obj = pool.borrowObject("one");

    // Borrow again with same key, should be blocked
    Runnable simple = new SimpleTestThread(pool, "one");
    Thread borrowThread = new Thread(simple);
    borrowThread.start();

    pool.borrowObject("two");
    assert (pool.getNumActive("one") == 1);
    assert (pool.getNumActive("two") == 1);

    // Unblock and join the thread
    pool.returnObject("one", obj);
    borrowThread.join();
    assert (pool.getNumActive("one") == 0);
    assert (pool.getNumActive("two") == 1);
}

---

From source file:edu.illinois.enforcemop.examples.apache.pool.TestGenericKeyedObjectPool.java

public void testExceptionOnPassivateDuringReturn() throws Exception {
    SimpleFactory factory = new SimpleFactory();
    GenericKeyedObjectPool pool = new GenericKeyedObjectPool(factory);
    Object obj = pool.borrowObject("one");
    factory.setThrowExceptionOnPassivate(true);
    pool.returnObject("one", obj);
    assertEquals(0, pool.getNumIdle());/*from w ww  .  j av  a 2 s  .co  m*/
    pool.close();
}

---

From source file:edu.illinois.enforcemop.examples.apache.pool.TestGenericKeyedObjectPool.java

public void testExceptionOnActivateDuringBorrow() throws Exception {
    SimpleFactory factory = new SimpleFactory();
    GenericKeyedObjectPool pool = new GenericKeyedObjectPool(factory);
    Object obj1 = pool.borrowObject("one");
    Object obj2 = pool.borrowObject("one");
    pool.returnObject("one", obj1);
    pool.returnObject("one", obj2);
    factory.setThrowExceptionOnActivate(true);
    factory.setEvenValid(false);/*from www . java2 s .  c  om*/
    // Activation will now throw every other time
    // First attempt throws, but loop continues and second succeeds
    Object obj = pool.borrowObject("one");
    assertEquals(1, pool.getNumActive("one"));
    assertEquals(0, pool.getNumIdle("one"));
    assertEquals(1, pool.getNumActive());
    assertEquals(0, pool.getNumIdle());

    pool.returnObject("one", obj);
    factory.setValid(false);
    // Validation will now fail on activation when borrowObject returns
    // an idle instance, and then when attempting to create a new instance
    try {
        pool.borrowObject("one");
        fail("Expecting NoSuchElementException");
    } catch (NoSuchElementException ex) {
        // expected
    }
    assertEquals(0, pool.getNumActive("one"));
    assertEquals(0, pool.getNumIdle("one"));
    assertEquals(0, pool.getNumActive());
    assertEquals(0, pool.getNumIdle());
}

---

From source file:edu.illinois.enforcemop.examples.apache.pool.TestGenericKeyedObjectPool.java

public void testExceptionOnDestroyDuringReturn() throws Exception {
    SimpleFactory factory = new SimpleFactory();
    factory.setThrowExceptionOnDestroy(true);
    factory.setValidationEnabled(true);/*  www. j av a  2s  .c  o m*/
    GenericKeyedObjectPool pool = new GenericKeyedObjectPool(factory);
    pool.setTestOnReturn(true);
    Object obj1 = pool.borrowObject("one");
    pool.borrowObject("one");
    factory.setValid(false); // Make validation fail
    pool.returnObject("one", obj1);
    assertEquals(1, pool.getNumActive("one"));
    assertEquals(0, pool.getNumIdle("one"));
    assertEquals(1, pool.getNumActive());
    assertEquals(0, pool.getNumIdle());
}

---

From source file:edu.illinois.enforcemop.examples.apache.pool.TestGenericKeyedObjectPool.java

@Test
// @Schedules({/* w  w  w.  j  av a 2 s  .  c  o m*/
//     @Schedule(name = "BorrowOneBeforeTwo", value = "[beforeBorrow:afterBorrow]@borrowThread -> borrowTwo@main")})
public void testBlockedKeyDoesNotBlockPoolImproved() throws Exception {
    SimpleFactory factory = new SimpleFactory();
    GenericKeyedObjectPool pool = new GenericKeyedObjectPool(factory);
    pool.setWhenExhaustedAction(GenericObjectPool.WHEN_EXHAUSTED_BLOCK);
    pool.setMaxActive(1);
    pool.setMaxTotal(-1);

    // Borrow with one key
    Object obj = pool.borrowObject("one");

    // Borrow again with same key, should be blocked
    Runnable simple = new SimpleTestThread(pool, "one");
    Thread borrowThread = new Thread(simple, "borrowThread");
    borrowThread.start();

    // Wait for sometime and borrow with another key
    // Should not block
    Thread.sleep(1000);
    pool.borrowObject("two");
    assertEquals(1, pool.getNumActive("one"));
    assertEquals(1, pool.getNumActive("two"));

    // Unblock and join the thread
    pool.returnObject("one", obj);
    borrowThread.join();
    assertEquals(0, pool.getNumActive("one"));
    assertEquals(1, pool.getNumActive("two"));
}

---

From source file:edu.illinois.imunit.examples.apache.pool.TestGenericKeyedObjectPool.java

@Test
@Schedules({/* w  w w  .ja  va  2  s  . c  om*/
        @Schedule(name = "BorrowOneBeforeTwo", value = "[beforeBorrow:afterBorrow]@borrowThread -> borrowTwo@main") })
public void testBlockedKeyDoesNotBlockPoolImproved() throws Exception {
    SimpleFactory factory = new SimpleFactory();
    GenericKeyedObjectPool pool = new GenericKeyedObjectPool(factory);
    pool.setWhenExhaustedAction(GenericObjectPool.WHEN_EXHAUSTED_BLOCK);
    pool.setMaxActive(1);
    pool.setMaxTotal(-1);

    // Borrow with one key
    Object obj = pool.borrowObject("one");

    // Borrow again with same key, should be blocked
    Runnable simple = new SimpleTestThread(pool, "one");
    Thread borrowThread = new Thread(simple, "borrowThread");
    borrowThread.start();

    // Wait for sometime and borrow with another key
    // Should not block
    Thread.sleep(1000);
    fireEvent("borrowTwo");
    pool.borrowObject("two");
    assertEquals(1, pool.getNumActive("one"));
    assertEquals(1, pool.getNumActive("two"));

    // Unblock and join the thread
    pool.returnObject("one", obj);
    borrowThread.join();
    assertEquals(0, pool.getNumActive("one"));
    assertEquals(1, pool.getNumActive("two"));
}

---

From source file:org.glassfish.grizzly.memcached.pool.BaseObjectPoolBenchmark.java

@Test
public void testBenchmarking() {
    final int loop = 2 * 1000 * 1000;
    final int poolSize = 150;

    final KeyedPoolableObjectFactory<String, String> apacheFactory = new KeyedPoolableObjectFactory<String, String>() {
        private static final String VALUE_NAME = "value";
        private int id;
        private int count;

        @Override//  ww  w  . ja v a  2 s  .com
        public synchronized String makeObject(String s) throws Exception {
            count++;
            return VALUE_NAME + ++id;
        }

        @Override
        public synchronized void destroyObject(String s, String s1) throws Exception {
            count--;
        }

        @Override
        public boolean validateObject(String s, String s1) {
            return true;
        }

        @Override
        public void activateObject(String s, String s1) throws Exception {
        }

        @Override
        public void passivateObject(String s, String s1) throws Exception {
        }
    };
    final GenericKeyedObjectPool<String, String> apachePool = new GenericKeyedObjectPool<String, String>(
            apacheFactory, poolSize, (byte) 0, 0, poolSize, poolSize, poolSize, false, false, 1000 * 60 * 60, 0,
            1000 * 60 * 60, false);
    String object = null;

    long startTime = System.currentTimeMillis();
    for (int i = 0; i < loop; i++) {
        try {
            object = apachePool.borrowObject("key");
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            apachePool.returnObject("key", object);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    logger.info("apache common-pool elapse = {}", (System.currentTimeMillis() - startTime));

    try {
        apachePool.close();
    } catch (Exception ignore) {
    }

    // grizzly
    final PoolableObjectFactory<String, String> grizzlyFactory = new PoolableObjectFactory<String, String>() {
        private static final String VALUE_NAME = "value";
        private int id;
        private int count;

        @Override
        public synchronized String createObject(String s) throws Exception {
            count++;
            return VALUE_NAME + ++id;
        }

        @Override
        public synchronized void destroyObject(String s, String s1) throws Exception {
            count--;
        }

        @Override
        public boolean validateObject(String s, String s1) {
            return true;
        }
    };
    final BaseObjectPool.Builder<String, String> builder = new BaseObjectPool.Builder<String, String>(
            grizzlyFactory);
    builder.disposable(false);
    builder.keepAliveTimeoutInSecs(-1);
    builder.borrowValidation(false);
    builder.returnValidation(false);
    builder.max(poolSize);
    builder.min(poolSize);
    final ObjectPool<String, String> grizzlyPool = builder.build();

    startTime = System.currentTimeMillis();
    for (int i = 0; i < loop; i++) {
        try {
            object = grizzlyPool.borrowObject("key", 100);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            grizzlyPool.returnObject("key", object);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    logger.info("grizzly pool elapse = {}", (System.currentTimeMillis() - startTime));

    grizzlyPool.destroy();
}

---

From source file:org.glassfish.grizzly.memcached.pool.BaseObjectPoolBenchmark.java

@Test
public void testBenchmarkingInMultiThreads() {
    final int threadCount = 1000;
    final int poolSize = 150;
    final KeyedPoolableObjectFactory<String, String> apacheFactory = new KeyedPoolableObjectFactory<String, String>() {
        private static final String VALUE_NAME = "value";
        private int id;
        private int count;

        @Override/*from  www . j  a  v a  2  s.c om*/
        public synchronized String makeObject(String s) throws Exception {
            count++;
            return VALUE_NAME + ++id;
        }

        @Override
        public synchronized void destroyObject(String s, String s1) throws Exception {
            count--;
        }

        @Override
        public boolean validateObject(String s, String s1) {
            return true;
        }

        @Override
        public void activateObject(String s, String s1) throws Exception {
        }

        @Override
        public void passivateObject(String s, String s1) throws Exception {
        }
    };
    final GenericKeyedObjectPool<String, String> apachePool = new GenericKeyedObjectPool<String, String>(
            apacheFactory, poolSize, GenericKeyedObjectPool.WHEN_EXHAUSTED_FAIL, 0, poolSize, poolSize,
            poolSize, false, false, 1000 * 60 * 60, 0, 1000 * 60 * 60, false);

    final ConcurrentLinkedQueue<String> borrowObjects = new ConcurrentLinkedQueue<String>();
    final CountDownLatch startFlag = new CountDownLatch(1);
    final CountDownLatch finishFlag = new CountDownLatch(threadCount * 2);
    final AtomicInteger exceptionCnt = new AtomicInteger();
    final AtomicInteger successCnt = new AtomicInteger();
    for (int i = 0; i < threadCount; i++) {
        final Thread borrowThread = new Thread() {
            @Override
            public void run() {
                try {
                    startFlag.await();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                for (int j = 0; j < 30; j++) {
                    try {
                        final String object = apachePool.borrowObject("key");
                        Assert.assertNotNull(object);
                        successCnt.incrementAndGet();
                        Assert.assertTrue(borrowObjects.offer(object));
                    } catch (Exception ignore) {
                        exceptionCnt.incrementAndGet();
                    }
                }
                finishFlag.countDown();
            }
        };
        borrowThread.start();

        final Thread returnThread = new Thread() {
            @Override
            public void run() {
                try {
                    startFlag.await();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                for (int j = 0; j < 30; j++) {
                    try {
                        final String object = borrowObjects.poll();
                        if (object != null) {
                            apachePool.returnObject("key", object);
                        }
                    } catch (Exception e) {
                        Assert.fail(e.getMessage());
                    }
                }
                finishFlag.countDown();
            }
        };
        returnThread.start();
    }
    long startTime = System.currentTimeMillis();
    startFlag.countDown();
    try {
        finishFlag.await();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    logger.info("apache common-pool elapse = {}", (System.currentTimeMillis() - startTime));
    try {
        logger.info("apache common-pool max gen-id = {}", apacheFactory.makeObject("key"));
    } catch (Exception ignore) {
    }
    logger.info("apache common-pool success counts = {}", successCnt.get());
    logger.info("apache common-pool exception counts = {}", exceptionCnt.get());

    try {
        apachePool.close();
    } catch (Exception ignore) {
    }

    // grizzly
    final PoolableObjectFactory<String, String> grizzlyFactory = new PoolableObjectFactory<String, String>() {
        private static final String VALUE_NAME = "value";
        private int id;
        private int count;

        @Override
        public synchronized String createObject(String s) throws Exception {
            count++;
            return VALUE_NAME + ++id;
        }

        @Override
        public synchronized void destroyObject(String s, String s1) throws Exception {
            count--;
        }

        @Override
        public boolean validateObject(String s, String s1) {
            return true;
        }
    };
    final BaseObjectPool.Builder<String, String> builder = new BaseObjectPool.Builder<String, String>(
            grizzlyFactory);
    builder.disposable(false);
    builder.keepAliveTimeoutInSecs(-1);
    builder.borrowValidation(false);
    builder.returnValidation(false);
    builder.max(poolSize);
    builder.min(poolSize);
    final ObjectPool<String, String> grizzlyPool = builder.build();

    final ConcurrentLinkedQueue<String> borrowObjects2 = new ConcurrentLinkedQueue<String>();
    final CountDownLatch startFlag2 = new CountDownLatch(1);
    final CountDownLatch finishFlag2 = new CountDownLatch(threadCount * 2);
    final AtomicInteger exceptionCnt2 = new AtomicInteger();
    final AtomicInteger successCnt2 = new AtomicInteger();
    for (int i = 0; i < threadCount; i++) {
        final Thread borrowThread = new Thread() {
            @Override
            public void run() {
                try {
                    startFlag2.await();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                for (int j = 0; j < 30; j++) {
                    try {
                        final String object = grizzlyPool.borrowObject("key", 0);
                        Assert.assertNotNull(object);
                        successCnt2.incrementAndGet();
                        Assert.assertTrue(borrowObjects2.offer(object));
                    } catch (Exception ignore) {
                        exceptionCnt2.incrementAndGet();
                    }
                }
                finishFlag2.countDown();
            }
        };
        borrowThread.start();

        final Thread returnThread = new Thread() {
            @Override
            public void run() {
                try {
                    startFlag2.await();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                for (int j = 0; j < 30; j++) {
                    try {
                        final String object = borrowObjects2.poll();
                        if (object != null) {
                            grizzlyPool.returnObject("key", object);
                        }
                    } catch (Exception e) {
                        Assert.fail(e.getMessage());
                    }
                }
                finishFlag2.countDown();
            }
        };
        returnThread.start();
    }
    startTime = System.currentTimeMillis();
    startFlag2.countDown();
    try {
        finishFlag2.await();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    logger.info("grizzly pool elapse = {}", (System.currentTimeMillis() - startTime));
    try {
        logger.info("grizzly pool max gen-id = {}", grizzlyFactory.createObject("key"));
    } catch (Exception ignore) {
    }
    logger.info("grizzly pool success counts = {}", successCnt2.get());
    logger.info("grizzly pool exception counts= {}", exceptionCnt2.get());

    grizzlyPool.destroy();
}

---

From source file:org.wso2.carbon.stream.processor.core.persistence.PersistenceManager.java

private EventSyncConnection getTCPConnection() {
    deploymentConfig = StreamProcessorDataHolder.getDeploymentConfig();
    GenericKeyedObjectPool tcpConnectionPool = EventSyncConnectionPoolManager.getConnectionPool();
    EventSyncConnection eventSyncConnection = null;
    try {/* w  w w.  j  av a 2 s.c  o m*/
        eventSyncConnection = (EventSyncConnection) tcpConnectionPool
                .borrowObject(HAConstants.ACTIVE_NODE_CONNECTION_POOL_ID);
        tcpConnectionPool.returnObject(HAConstants.ACTIVE_NODE_CONNECTION_POOL_ID, eventSyncConnection);
    } catch (Exception e) {
        log.error("Error in getting a connection to the Passive node. " + e.getMessage());
    }
    return eventSyncConnection;
}

---