Examples with PooledObjectState org.datanucleus.store.rdbms.datasource.dbcp2.pool2.PooledObjectState used on opensource projects

Example 1 with PooledObjectState

use of org.datanucleus.store.rdbms.datasource.dbcp2.pool2.PooledObjectState in project datanucleus-rdbms by datanucleus.

the class GenericKeyedObjectPool method returnObject.

/**
 * Returns an object to a keyed sub-pool.
 * <p>
 * If {@link #getMaxIdlePerKey() maxIdle} is set to a positive value and the
 * number of idle instances under the given key has reached this value, the
 * returning instance is destroyed.
 * <p>
 * If {@link #getTestOnReturn() testOnReturn} == true, the returning
 * instance is validated before being returned to the idle instance sub-pool
 * under the given key. In this case, if validation fails, the instance is
 * destroyed.
 * <p>
 * Exceptions encountered destroying objects for any reason are swallowed
 * but notified via a {@link SwallowedExceptionListener}.
 *
 * @param key pool key
 * @param obj instance to return to the keyed pool
 *
 * @throws IllegalStateException if an object is returned to the pool that
 *                               was not borrowed from it or if an object is
 *                               returned to the pool multiple times
 */
@Override
public void returnObject(K key, T obj) {
    ObjectDeque<T> objectDeque = poolMap.get(key);
    PooledObject<T> p = objectDeque.getAllObjects().get(new IdentityWrapper<T>(obj));
    if (p == null) {
        throw new IllegalStateException("Returned object not currently part of this pool");
    }
    synchronized (p) {
        final PooledObjectState state = p.getState();
        if (state != PooledObjectState.ALLOCATED) {
            throw new IllegalStateException("Object has already been returned to this pool or is invalid");
        }
        // Keep from being marked abandoned (once GKOP does this)
        p.markReturning();
    }
    long activeTime = p.getActiveTimeMillis();
    if (getTestOnReturn()) {
        if (!factory.validateObject(key, p)) {
            try {
                destroy(key, p, true);
            } catch (Exception e) {
                swallowException(e);
            }
            if (objectDeque.idleObjects.hasTakeWaiters()) {
                try {
                    addObject(key);
                } catch (Exception e) {
                    swallowException(e);
                }
            }
            updateStatsReturn(activeTime);
            return;
        }
    }
    try {
        factory.passivateObject(key, p);
    } catch (Exception e1) {
        swallowException(e1);
        try {
            destroy(key, p, true);
        } catch (Exception e) {
            swallowException(e);
        }
        if (objectDeque.idleObjects.hasTakeWaiters()) {
            try {
                addObject(key);
            } catch (Exception e) {
                swallowException(e);
            }
        }
        updateStatsReturn(activeTime);
        return;
    }
    if (!p.deallocate()) {
        throw new IllegalStateException("Object has already been returned to this pool");
    }
    int maxIdle = getMaxIdlePerKey();
    LinkedBlockingDeque<PooledObject<T>> idleObjects = objectDeque.getIdleObjects();
    if (isClosed() || maxIdle > -1 && maxIdle <= idleObjects.size()) {
        try {
            destroy(key, p, true);
        } catch (Exception e) {
            swallowException(e);
        }
    } else {
        if (getLifo()) {
            idleObjects.addFirst(p);
        } else {
            idleObjects.addLast(p);
        }
        if (isClosed()) {
            // Pool closed while object was being added to idle objects.
            // Make sure the returned object is destroyed rather than left
            // in the idle object pool (which would effectively be a leak)
            clear(key);
        }
    }
    if (hasBorrowWaiters()) {
        reuseCapacity();
    }
    updateStatsReturn(activeTime);
}

Example 2 with PooledObjectState

use of org.datanucleus.store.rdbms.datasource.dbcp2.pool2.PooledObjectState in project weicoder by wdcode.

the class BaseGenericObjectPool method markReturningState.

/**
 * Marks the object as returning to the pool.
 * @param pooledObject instance to return to the keyed pool
 */
protected void markReturningState(final PooledObject<T> pooledObject) {
    synchronized (pooledObject) {
        final PooledObjectState state = pooledObject.getState();
        if (state != PooledObjectState.ALLOCATED) {
            throw new IllegalStateException("Object has already been returned to this pool or is invalid");
        }
        // Keep from being marked abandoned
        pooledObject.markReturning();
    }
}

Example 3 with PooledObjectState

use of org.datanucleus.store.rdbms.datasource.dbcp2.pool2.PooledObjectState in project datanucleus-rdbms by datanucleus.

the class GenericObjectPool method returnObject.

/**
 * {@inheritDoc}
 * <p>
 * If {@link #getMaxIdle() maxIdle} is set to a positive value and the
 * number of idle instances has reached this value, the returning instance
 * is destroyed.
 * <p>
 * If {@link #getTestOnReturn() testOnReturn} == true, the returning
 * instance is validated before being returned to the idle instance pool. In
 * this case, if validation fails, the instance is destroyed.
 * <p>
 * Exceptions encountered destroying objects for any reason are swallowed
 * but notified via a {@link SwallowedExceptionListener}.
 */
@Override
public void returnObject(T obj) {
    PooledObject<T> p = allObjects.get(new IdentityWrapper<T>(obj));
    if (p == null) {
        if (!isAbandonedConfig()) {
            throw new IllegalStateException("Returned object not currently part of this pool");
        }
        // Object was abandoned and removed
        return;
    }
    synchronized (p) {
        final PooledObjectState state = p.getState();
        if (state != PooledObjectState.ALLOCATED) {
            throw new IllegalStateException("Object has already been returned to this pool or is invalid");
        }
        // Keep from being marked abandoned
        p.markReturning();
    }
    long activeTime = p.getActiveTimeMillis();
    if (getTestOnReturn()) {
        if (!factory.validateObject(p)) {
            try {
                destroy(p);
            } catch (Exception e) {
                swallowException(e);
            }
            try {
                ensureIdle(1, false);
            } catch (Exception e) {
                swallowException(e);
            }
            updateStatsReturn(activeTime);
            return;
        }
    }
    try {
        factory.passivateObject(p);
    } catch (Exception e1) {
        swallowException(e1);
        try {
            destroy(p);
        } catch (Exception e) {
            swallowException(e);
        }
        try {
            ensureIdle(1, false);
        } catch (Exception e) {
            swallowException(e);
        }
        updateStatsReturn(activeTime);
        return;
    }
    if (!p.deallocate()) {
        throw new IllegalStateException("Object has already been returned to this pool or is invalid");
    }
    int maxIdleSave = getMaxIdle();
    if (isClosed() || maxIdleSave > -1 && maxIdleSave <= idleObjects.size()) {
        try {
            destroy(p);
        } catch (Exception e) {
            swallowException(e);
        }
    } else {
        if (getLifo()) {
            idleObjects.addFirst(p);
        } else {
            idleObjects.addLast(p);
        }
        if (isClosed()) {
            // Pool closed while object was being added to idle objects.
            // Make sure the returned object is destroyed rather than left
            // in the idle object pool (which would effectively be a leak)
            clear();
        }
    }
    updateStatsReturn(activeTime);
}

Example 4 with PooledObjectState

use of org.datanucleus.store.rdbms.datasource.dbcp2.pool2.PooledObjectState in project datanucleus-rdbms by datanucleus.

the class BaseGenericObjectPool method markReturningState.

/**
 * Marks the object as returning to the pool.
 * @param pooledObject instance to return to the keyed pool
 */
protected void markReturningState(final PooledObject<T> pooledObject) {
    synchronized (pooledObject) {
        final PooledObjectState state = pooledObject.getState();
        if (state != PooledObjectState.ALLOCATED) {
            throw new IllegalStateException("Object has already been returned to this pool or is invalid");
        }
        // Keep from being marked abandoned
        pooledObject.markReturning();
    }
}