java.lang.Object
- org.apache.http.pool.AbstractConnPool<T,C,E>

Type Parameters:

T - the route type that represents the opposite endpoint of a pooled connection.

C - the connection type.

E - the type of the pool entry containing a pooled connection.

All Implemented Interfaces:

ConnPool<T,E>, ConnPoolControl<T>

Direct Known Subclasses:

BasicConnPool
```
@Contract(threading=SAFE_CONDITIONAL)
public abstract class AbstractConnPool<T,C,E extends PoolEntry<T,C>>
extends java.lang.Object
implements ConnPool<T,E>, ConnPoolControl<T>
```
Abstract synchronous (blocking) pool of connections.
Please note that this class does not maintain its own pool of execution Threads. Therefore, one must call Future.get() or Future.get(long, TimeUnit) method on the Future object returned by the lease(Object, Object, FutureCallback) method in order for the lease operation to complete.

Since:

4.2

Field Summary

Fields
Modifier and Type	Field	Description
`private java.util.LinkedList<E>`	`available`
`private java.util.concurrent.locks.Condition`	`condition`
`private ConnFactory<T,C>`	`connFactory`
`private int`	`defaultMaxPerRoute`
`private boolean`	`isShutDown`
`private java.util.Set<E>`	`leased`
`private java.util.concurrent.locks.Lock`	`lock`
`private java.util.Map<T,java.lang.Integer>`	`maxPerRoute`
`private int`	`maxTotal`
`private java.util.LinkedList<java.util.concurrent.Future<E>>`	`pending`
`private java.util.Map<T,RouteSpecificPool<T,C,E>>`	`routeToPool`
`private int`	`validateAfterInactivity`

Constructor Summary

Constructors
Constructor Description

AbstractConnPool(ConnFactory<T,C> connFactory, int defaultMaxPerRoute, int maxTotal)

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`closeExpired()`	Closes expired connections and evicts them from the pool.
`void`	`closeIdle(long idletime, java.util.concurrent.TimeUnit timeUnit)`	Closes connections that have been idle longer than the given period of time and evicts them from the pool.
`protected abstract E`	`createEntry(T route, C conn)`	Creates a new entry for the given connection with the given route.
`protected void`	`enumAvailable(PoolEntryCallback<T,C> callback)`	Enumerates all available connections.
`protected void`	`enumLeased(PoolEntryCallback<T,C> callback)`	Enumerates all leased connections.
`int`	`getDefaultMaxPerRoute()`
`private int`	`getMax(T route)`
`int`	`getMaxPerRoute(T route)`
`int`	`getMaxTotal()`
`private RouteSpecificPool<T,C,E>`	`getPool(T route)`
`private E`	`getPoolEntryBlocking(T route, java.lang.Object state, long timeout, java.util.concurrent.TimeUnit timeUnit, java.util.concurrent.Future<E> future)`
`java.util.Set<T>`	`getRoutes()`	Returns snapshot of all knows routes
`PoolStats`	`getStats(T route)`
`PoolStats`	`getTotalStats()`
`int`	`getValidateAfterInactivity()`
`boolean`	`isShutdown()`
`java.util.concurrent.Future<E>`	`lease(T route, java.lang.Object state)`	Attempts to lease a connection for the given route and with the given state from the pool.
`java.util.concurrent.Future<E>`	`lease(T route, java.lang.Object state, FutureCallback<E> callback)`	Attempts to lease a connection for the given route and with the given state from the pool.
`protected void`	`onLease(E entry)`
`protected void`	`onRelease(E entry)`
`protected void`	`onReuse(E entry)`
`private static java.lang.Exception`	`operationAborted()`
`private void`	`purgePoolMap()`
`void`	`release(E entry, boolean reusable)`	Releases the pool entry back to the pool.
`void`	`setDefaultMaxPerRoute(int max)`
`void`	`setMaxPerRoute(T route, int max)`
`void`	`setMaxTotal(int max)`
`void`	`setValidateAfterInactivity(int ms)`
`void`	`shutdown()`	Shuts down the pool.
`java.lang.String`	`toString()`
`protected boolean`	`validate(E entry)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - lock
```
private final java.util.concurrent.locks.Lock lock
```
  - condition
```
private final java.util.concurrent.locks.Condition condition
```
  - connFactory
```
private final ConnFactory<T,C> connFactory
```
  - routeToPool
```
private final java.util.Map<T,RouteSpecificPool<T,C,E extends PoolEntry<T,C>>> routeToPool
```
  - leased
```
private final java.util.Set<E extends PoolEntry<T,C>> leased
```
  - available
```
private final java.util.LinkedList<E extends PoolEntry<T,C>> available
```
  - pending
```
private final java.util.LinkedList<java.util.concurrent.Future<E extends PoolEntry<T,C>>> pending
```
  - maxPerRoute
```
private final java.util.Map<T,java.lang.Integer> maxPerRoute
```
  - isShutDown
```
private volatile boolean isShutDown
```
  - defaultMaxPerRoute
```
private volatile int defaultMaxPerRoute
```
  - maxTotal
```
private volatile int maxTotal
```
  - validateAfterInactivity
```
private volatile int validateAfterInactivity
```
- Constructor Detail
  - AbstractConnPool
```
public AbstractConnPool(ConnFactory<T,C> connFactory,
                        int defaultMaxPerRoute,
                        int maxTotal)
```
- Method Detail
  - createEntry
```
protected abstract E createEntry(T route,
                                 C conn)
```
    Creates a new entry for the given connection with the given route.
  - onLease
```
protected void onLease(E entry)
```
    Since:
    
    4.3
  - onRelease
```
protected void onRelease(E entry)
```
    Since:
    
    4.3
  - onReuse
```
protected void onReuse(E entry)
```
    Since:
    
    4.4
  - validate
```
protected boolean validate(E entry)
```
    Since:
    
    4.4
  - isShutdown
```
public boolean isShutdown()
```
  - shutdown
```
public void shutdown()
              throws java.io.IOException
```
    Shuts down the pool.
    
    Throws:
    
    java.io.IOException
  - getPool
```
private RouteSpecificPool<T,C,E> getPool(T route)
```
  - operationAborted
```
private static java.lang.Exception operationAborted()
```
  - lease
```
public java.util.concurrent.Future<E> lease(T route,
                                            java.lang.Object state,
                                            FutureCallback<E> callback)
```
    Attempts to lease a connection for the given route and with the given state from the pool.
    Please note that this class does not maintain its own pool of execution Threads. Therefore, one must call Future.get() or Future.get(long, TimeUnit) method on the Future returned by this method in order for the lease operation to complete.
    
    Specified by:
    
    lease in interface ConnPool<T,C>
    
    Parameters:
    
    route - route of the connection.
    
    state - arbitrary object that represents a particular state (usually a security principal or a unique token identifying the user whose credentials have been used while establishing the connection). May be null.
    
    callback - operation completion callback.
    
    Returns:
    
    future for a leased pool entry.
  - lease
```
public java.util.concurrent.Future<E> lease(T route,
                                            java.lang.Object state)
```
    Attempts to lease a connection for the given route and with the given state from the pool.
    Please note that this class does not maintain its own pool of execution Threads. Therefore, one must call Future.get() or Future.get(long, TimeUnit) method on the Future returned by this method in order for the lease operation to complete.
    
    Parameters:
    
    route - route of the connection.
    
    state - arbitrary object that represents a particular state (usually a security principal or a unique token identifying the user whose credentials have been used while establishing the connection). May be null.
    
    Returns:
    
    future for a leased pool entry.
  - getPoolEntryBlocking
```
private E getPoolEntryBlocking(T route,
                               java.lang.Object state,
                               long timeout,
                               java.util.concurrent.TimeUnit timeUnit,
                               java.util.concurrent.Future<E> future)
                        throws java.io.IOException,
                               java.lang.InterruptedException,
                               java.util.concurrent.ExecutionException,
                               java.util.concurrent.TimeoutException
```
    Throws:
    
    java.io.IOException
    
    java.lang.InterruptedException
    
    java.util.concurrent.ExecutionException
    
    java.util.concurrent.TimeoutException
  - release
```
public void release(E entry,
                    boolean reusable)
```
    Description copied from interface: ConnPool
    
    Releases the pool entry back to the pool.
    
    Specified by:
    
    release in interface ConnPool<T,C>
    
    Parameters:
    
    entry - pool entry leased from the pool
    
    reusable - flag indicating whether or not the released connection is in a consistent state and is safe for further use.
  - getMax
```
private int getMax(T route)
```
  - setMaxTotal
```
public void setMaxTotal(int max)
```
    Specified by:
    
    setMaxTotal in interface ConnPoolControl<T>
  - getMaxTotal
```
public int getMaxTotal()
```
    Specified by:
    
    getMaxTotal in interface ConnPoolControl<T>
  - setDefaultMaxPerRoute
```
public void setDefaultMaxPerRoute(int max)
```
    Specified by:
    
    setDefaultMaxPerRoute in interface ConnPoolControl<T>
  - getDefaultMaxPerRoute
```
public int getDefaultMaxPerRoute()
```
    Specified by:
    
    getDefaultMaxPerRoute in interface ConnPoolControl<T>
  - setMaxPerRoute
```
public void setMaxPerRoute(T route,
                           int max)
```
    Specified by:
    
    setMaxPerRoute in interface ConnPoolControl<T>
  - getMaxPerRoute
```
public int getMaxPerRoute(T route)
```
    Specified by:
    
    getMaxPerRoute in interface ConnPoolControl<T>
  - getTotalStats
```
public PoolStats getTotalStats()
```
    Specified by:
    
    getTotalStats in interface ConnPoolControl<T>
  - getStats
```
public PoolStats getStats(T route)
```
    Specified by:
    
    getStats in interface ConnPoolControl<T>
  - getRoutes
```
public java.util.Set<T> getRoutes()
```
    Returns snapshot of all knows routes
    
    Returns:
    
    the set of routes
    
    Since:
    
    4.4
  - enumAvailable
```
protected void enumAvailable(PoolEntryCallback<T,C> callback)
```
    Enumerates all available connections.
    
    Since:
    
    4.3
  - enumLeased
```
protected void enumLeased(PoolEntryCallback<T,C> callback)
```
    Enumerates all leased connections.
    
    Since:
    
    4.3
  - purgePoolMap
```
private void purgePoolMap()
```
  - closeIdle
```
public void closeIdle(long idletime,
                      java.util.concurrent.TimeUnit timeUnit)
```
    Closes connections that have been idle longer than the given period of time and evicts them from the pool.
    
    Parameters:
    
    idletime - maximum idle time.
    
    timeUnit - time unit.
  - closeExpired
```
public void closeExpired()
```
    Closes expired connections and evicts them from the pool.
  - getValidateAfterInactivity
```
public int getValidateAfterInactivity()
```
    Returns:
    
    the number of milliseconds
    
    Since:
    
    4.4
  - setValidateAfterInactivity
```
public void setValidateAfterInactivity(int ms)
```
    Parameters:
    
    ms - the number of milliseconds
    
    Since:
    
    4.4
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class AbstractConnPool<T,​C,​E extends PoolEntry<T,​C>>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

lock

condition

connFactory

routeToPool

leased

available

pending

maxPerRoute

isShutDown

defaultMaxPerRoute

maxTotal

validateAfterInactivity

Constructor Detail

AbstractConnPool

Method Detail

createEntry

onLease

onRelease

onReuse

validate

isShutdown

shutdown

getPool

operationAborted

lease

lease

getPoolEntryBlocking

release

getMax

setMaxTotal

getMaxTotal

setDefaultMaxPerRoute

getDefaultMaxPerRoute

setMaxPerRoute

getMaxPerRoute

getTotalStats

getStats

getRoutes

enumAvailable

enumLeased

purgePoolMap

closeIdle

closeExpired

getValidateAfterInactivity

setValidateAfterInactivity

toString

Class AbstractConnPool<T,C,E extends PoolEntry<T,C>>