Java ObjectPool.returnObject方法代码示例

import org.apache.commons.pool.ObjectPool; //导入方法依赖的package包/类
public void releaseJdbcConnection(JdbcConnectionDescriptor jcd, Connection con)
        throws LookupException
{
    final ObjectPool op = (ObjectPool) poolMap.get(jcd.getPBKey());
    try
    {
        /* mkalen: NB - according to the Commons Pool API we should _not_ perform
         * any additional checks here since we will then break testOnX semantics
         *
         * To enable Connection validation on releaseJdbcConnection,
         * set a validation query and specify testOnRelease=true
         *
         * Destruction of pooled objects is performed by the actual Commons Pool
         * ObjectPool implementation when the object factory's validateObject method
         * returns false. See ConPoolFactory#validateObject.
         */
        op.returnObject(con);
    }
    catch (Exception e)
    {
        throw new LookupException(e);
    }
}
 

import org.apache.commons.pool.ObjectPool; //导入方法依赖的package包/类
/**
 * @deprecated - to be removed in pool 2.0
 */
public void testPoolWithNullFactory() throws Exception {
    ObjectPool pool = new StackObjectPool(10);
    for(int i=0;i<10;i++) {
        pool.returnObject(new Integer(i));
    }
    for(int j=0;j<3;j++) {
        Integer[] borrowed = new Integer[10];
        BitSet found = new BitSet();
        for(int i=0;i<10;i++) {
            borrowed[i] = (Integer)(pool.borrowObject());
            assertNotNull(borrowed);
            assertTrue(!found.get(borrowed[i].intValue()));
            found.set(borrowed[i].intValue());
        }
        for(int i=0;i<10;i++) {
            pool.returnObject(borrowed[i]);
        }
    }
    pool.invalidateObject(pool.borrowObject());
    pool.invalidateObject(pool.borrowObject());
    pool.clear();        
}
 

import org.apache.commons.pool.ObjectPool; //导入方法依赖的package包/类
/**
 * Verifies that validation and passivation failures returning objects are handled
 * properly - instances destroyed and not returned to the pool, but no exceptions propagated.
 */
public void testBorrowReturnWithSometimesInvalidObjects() throws Exception {
    SelectiveFactory factory = new SelectiveFactory();
    ObjectPool pool = new StackObjectPool(factory, 20);

    Object[] obj = new Object[10];
    for(int i=0;i<10;i++) {
        obj[i] = pool.borrowObject();
        assertEquals("Each time we borrow, get one more active.", i+1, pool.getNumActive());
        
    }
    
    factory.setValidateSelectively(true);  // Even numbers fail validation
    factory.setPassivateSelectively(true); // Multiples of 3 fail passivation

    for(int i=0;i<10;i++) {
        pool.returnObject(obj[i]);
        assertEquals("Each time we return, get one less active.", 9-i, pool.getNumActive());
    }
    // 0,2,4,6,8 fail validation, 3, 9 fail passivation - 3 left.
    assertEquals(3,pool.getNumIdle());
}
 

import org.apache.commons.pool.ObjectPool; //导入方法依赖的package包/类
/**
 * Verifies that exceptions thrown by factory destroy are swallowed
 * by both addObject and returnObject.
 */
public void testExceptionOnDestroy() throws Exception {
    SelectiveFactory factory = new SelectiveFactory();
    ObjectPool pool = new StackObjectPool(factory, 2);
    factory.setThrowOnDestroy(true);
    for (int i = 0; i < 3; i++) {
        pool.addObject(); // Third one will destroy, exception should be swallowed
    }
    assertEquals(2, pool.getNumIdle());
    
    Object[] objects = new Object[3];
    for (int i = 0; i < 3; i++) {
        objects[i] = pool.borrowObject();
    }
    for (int i = 0; i < 3; i++) {
        pool.returnObject(objects[i]); // Third triggers destroy
    } 
    assertEquals(2, pool.getNumIdle());
}
 

import org.apache.commons.pool.ObjectPool; //导入方法依赖的package包/类
/**
 * Verifies that addObject propagates exceptions thrown by
 * factory passivate, but returnObject swallows these.
 */
public void testExceptionOnPassivate() throws Exception {
    SelectiveFactory factory = new SelectiveFactory();
    ObjectPool pool = new StackObjectPool(factory, 2);
    factory.setThrowOnPassivate(true);
    
    // addObject propagates
    try {
        pool.addObject();
        fail("Expecting IntegerFactoryException");
    } catch (IntegerFactoryException ex) {
        assertEquals("passivateObject", ex.getType());
        assertEquals(0, ex.getValue());
    }
    assertEquals(0, pool.getNumIdle());
    
    // returnObject swallows 
    Object obj = pool.borrowObject();
    pool.returnObject(obj);
    assertEquals(0, pool.getNumIdle());
}
 

import org.apache.commons.pool.ObjectPool; //导入方法依赖的package包/类
public void process() throws Exception
  {
      Object queueElement = this.queue.take();

if (!(queueElement instanceof ListenerRequest))
      {
          throw new IllegalArgumentException("Expected ListenerRequest but found " + queueElement.getClass().getName());
      }

ListenerRequest request = (ListenerRequest) queueElement;

try
{
	processRequest(request);
}
finally
{
	ObjectPool pool = request.getBorrowedFromPool();
	
       if (pool != null)
       {
       	pool.returnObject(request);
       }
}
  }
 

import org.apache.commons.pool.ObjectPool; //导入方法依赖的package包/类
/**
 * Returns the given object to the pool.
 *
 * @param pool   The pool to where return the object to.
 * @param object The object to be returned to the pool.
 */
private void returnObject(ObjectPool<Classifier> pool, Classifier object) {
    try {
        pool.returnObject(object);
    } catch (Exception e) {
        logger.error("Could not return object to pool", e);
    }
}
 

import org.apache.commons.pool.ObjectPool; //导入方法依赖的package包/类
public void testIdleCap() throws Exception {
    ObjectPool pool = makeEmptyPool(8);
    Object[] active = new Object[100];
    for(int i=0;i<100;i++) {
        active[i] = pool.borrowObject();
    }
    assertEquals(100,pool.getNumActive());
    assertEquals(0,pool.getNumIdle());
    for(int i=0;i<100;i++) {
        pool.returnObject(active[i]);
        assertEquals(99 - i,pool.getNumActive());
        assertEquals((i < 8 ? i+1 : 8),pool.getNumIdle());
    }
}
 

import org.apache.commons.pool.ObjectPool; //导入方法依赖的package包/类
/**
 * @deprecated - to be removed in pool 2.0
 */
public void testSetFactory() throws Exception {
    ObjectPool pool = new StackObjectPool();
    try {
        pool.borrowObject();
        fail("Expected NoSuchElementException");
    } catch(NoSuchElementException e) {
        // expected
    }
    pool.setFactory(new SimpleFactory());
    Object obj = pool.borrowObject();
    assertNotNull(obj);
    pool.returnObject(obj);
}
 

import org.apache.commons.pool.ObjectPool; //导入方法依赖的package包/类
/**
 * Verifies that validation failures when borrowing newly created instances
 * from the pool result in NoSuchElementExceptions and passivation failures
 * result in instances not being returned to the pool.
 */
public void testBorrowWithSometimesInvalidObjects() throws Exception {
    SelectiveFactory factory = new SelectiveFactory();
    factory.setValidateSelectively(true);  // Even numbers fail validation
    factory.setPassivateSelectively(true); // Multiples of 3 fail passivation
    ObjectPool pool = new StackObjectPool(factory, 20);
    Object[] obj = new Object[10];
    for(int i=0;i<10;i++) {
        Object object = null;
        int k = 0;
        while (object == null && k < 100) { // bound not really needed
            try {
                k++;
                object = pool.borrowObject();
                if (((Integer) object).intValue() % 2 == 0) {
                    fail("Expecting NoSuchElementException");
                } else {
                    obj[i] = object; 
                }
            } catch (NoSuchElementException ex) {
                // Should fail for evens
            }
        }
        assertEquals("Each time we borrow, get one more active.", i+1, pool.getNumActive());
    }
    // 1,3,5,...,19 pass validation, get checked out
    for(int i=0;i<10;i++) {
        pool.returnObject(obj[i]);
        assertEquals("Each time we return, get one less active.", 9-i, pool.getNumActive());
    }
    // 3, 9, 15 fail passivation.  
    assertEquals(7,pool.getNumIdle());
    assertEquals(new Integer(19), pool.borrowObject());
    assertEquals(new Integer(17), pool.borrowObject());
    assertEquals(new Integer(13), pool.borrowObject());
    assertEquals(new Integer(11), pool.borrowObject());
    assertEquals(new Integer(7), pool.borrowObject());
    assertEquals(new Integer(5), pool.borrowObject());
    assertEquals(new Integer(1), pool.borrowObject());     
}
 

import org.apache.commons.pool.ObjectPool; //导入方法依赖的package包/类
/**
 * Verifies that when returning objects cause maxSleeping exceeded, oldest instances
 * are destroyed to make room for returning objects.
 */
public void testReturnObjectDiscardOrder() throws Exception {
    SelectiveFactory factory = new SelectiveFactory();
    ObjectPool pool = new StackObjectPool(factory, 3);

    // borrow more objects than the pool can hold
    Integer i0 = (Integer)pool.borrowObject();
    Integer i1 = (Integer)pool.borrowObject();
    Integer i2 = (Integer)pool.borrowObject();
    Integer i3 = (Integer)pool.borrowObject();

    // tests
    // return as many as the pool will hold.
    pool.returnObject(i0);
    pool.returnObject(i1);
    pool.returnObject(i2);

    // the pool should now be full.
    assertEquals("No returned objects should have been destroyed yet.", 0,  factory.getDestroyed().size());

    // cause the pool to discard a stale object.
    pool.returnObject(i3);
    assertEquals("One object should have been destroyed.", 1, factory.getDestroyed().size());

    // check to see what object was destroyed
    Integer d = (Integer)factory.getDestroyed().get(0);
    assertEquals("Destoryed object should be the stalest object.", i0, d);
}