ConnPoolByRoute (cloudwise-mobile-obfus 1.6.5 API)

java.lang.Object
- depends.org.apache.http.impl.conn.tsccm.AbstractConnPool
- - depends.org.apache.http.impl.conn.tsccm.ConnPoolByRoute

已过时。
(4.2) use AbstractConnPool
```
@Deprecated
public class ConnPoolByRoute
extends AbstractConnPool
```
A connection pool that maintains connections by route. This class is derived from MultiThreadedHttpConnectionManager in HttpClient 3.x, see there for original authors. It implements the same algorithm for connection re-use and connection-per-host enforcement:
- connections are re-used only for the exact same route
- connection limits are enforced per route rather than per host
Note that access to the pool data structures is synchronized via the poolLock in the base class, not via synchronized methods.
从以下版本开始:

4.0

字段概要

字段
限定符和类型	字段和说明
`protected ConnPerRoute`	`connPerRoute` 已过时。 Connections per route lookup
`protected java.util.Queue<BasicPoolEntry>`	`freeConnections` 已过时。 The list of free connections
`protected java.util.Set<BasicPoolEntry>`	`leasedConnections` 已过时。 References to issued connections
`protected int`	`maxTotalConnections` 已过时。
`protected int`	`numConnections` 已过时。
`protected ClientConnectionOperator`	`operator` 已过时。 Connection operator for this pool
`protected java.util.Map<HttpRoute,RouteSpecificPool>`	`routeToPool` 已过时。 Map of route-specific pools
`protected boolean`	`shutdown` 已过时。
`protected java.util.Queue<WaitingThread>`	`waitingThreads` 已过时。 The list of WaitingThreads waiting for a connection

从类继承的字段 depends.org.apache.http.impl.conn.tsccm.AbstractConnPool
idleConnHandler, isShutDown, issuedConnections, refQueue

构造器概要

构造器
构造器和说明
`ConnPoolByRoute(ClientConnectionOperator operator, ConnPerRoute connPerRoute, int maxTotalConnections)` 已过时。 Creates a new connection pool, managed by route.
`ConnPoolByRoute(ClientConnectionOperator operator, ConnPerRoute connPerRoute, int maxTotalConnections, long connTTL, java.util.concurrent.TimeUnit connTTLTimeUnit)` 已过时。
`ConnPoolByRoute(ClientConnectionOperator operator, HttpParams params)` 已过时。 (4.1) use `ConnPoolByRoute(ClientConnectionOperator, ConnPerRoute, int)`

方法概要

方法
限定符和类型	方法和说明
`void`	`closeExpiredConnections()` 已过时。
`void`	`closeIdleConnections(long idletime, java.util.concurrent.TimeUnit tunit)` 已过时。 Closes idle connections.
`protected BasicPoolEntry`	`createEntry(RouteSpecificPool rospl, ClientConnectionOperator op)` 已过时。 Creates a new pool entry.
`protected java.util.Queue<BasicPoolEntry>`	`createFreeConnQueue()` 已过时。 Creates the queue for `freeConnections`.
`protected java.util.Map<HttpRoute,RouteSpecificPool>`	`createRouteToPoolMap()` 已过时。 Creates the map for `routeToPool`.
`protected java.util.Queue<WaitingThread>`	`createWaitingThreadQueue()` 已过时。 Creates the queue for `waitingThreads`.
`void`	`deleteClosedConnections()` 已过时。 Deletes all entries for closed connections.
`protected void`	`deleteEntry(BasicPoolEntry entry)` 已过时。 Deletes a given pool entry.
`protected void`	`deleteLeastUsedEntry()` 已过时。 Delete an old, free pool entry to make room for a new one.
`void`	`freeEntry(BasicPoolEntry entry, boolean reusable, long validDuration, java.util.concurrent.TimeUnit timeUnit)` 已过时。 Returns an entry into the pool.
`int`	`getConnectionsInPool()` 已过时。
`int`	`getConnectionsInPool(HttpRoute route)` 已过时。
`protected BasicPoolEntry`	`getEntryBlocking(HttpRoute route, java.lang.Object state, long timeout, java.util.concurrent.TimeUnit tunit, WaitingThreadAborter aborter)` 已过时。 Obtains a pool entry with a connection within the given timeout.
`protected BasicPoolEntry`	`getFreeEntry(RouteSpecificPool rospl, java.lang.Object state)` 已过时。 If available, get a free pool entry for a route.
`protected java.util.concurrent.locks.Lock`	`getLock()` 已过时。
`int`	`getMaxTotalConnections()` 已过时。 since 4.1
`protected RouteSpecificPool`	`getRoutePool(HttpRoute route, boolean create)` 已过时。 Get a route-specific pool of available connections.
`protected void`	`handleLostEntry(HttpRoute route)` 已过时。
`protected RouteSpecificPool`	`newRouteSpecificPool(HttpRoute route)` 已过时。 Creates a new route-specific pool.
`protected WaitingThread`	`newWaitingThread(java.util.concurrent.locks.Condition cond, RouteSpecificPool rospl)` 已过时。 Creates a new waiting thread.
`protected void`	`notifyWaitingThread(RouteSpecificPool rospl)` 已过时。 Notifies a waiting thread that a connection is available.
`PoolEntryRequest`	`requestPoolEntry(HttpRoute route, java.lang.Object state)` 已过时。 Returns a new `PoolEntryRequest`, from which a `BasicPoolEntry` can be obtained, or the request can be aborted.
`void`	`setMaxTotalConnections(int max)` 已过时。 since 4.1
`void`	`shutdown()` 已过时。 Shuts down this pool and all associated resources.

从类继承的方法 depends.org.apache.http.impl.conn.tsccm.AbstractConnPool
closeConnection, enableConnectionGC, getEntry, handleReference

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 字段详细资料
  - operator
```
protected final ClientConnectionOperator operator
```
    已过时。
    
    Connection operator for this pool
  - connPerRoute
```
protected final ConnPerRoute connPerRoute
```
    已过时。
    
    Connections per route lookup
  - leasedConnections
```
protected final java.util.Set<BasicPoolEntry> leasedConnections
```
    已过时。
    
    References to issued connections
  - freeConnections
```
protected final java.util.Queue<BasicPoolEntry> freeConnections
```
    已过时。
    
    The list of free connections
  - waitingThreads
```
protected final java.util.Queue<WaitingThread> waitingThreads
```
    已过时。
    
    The list of WaitingThreads waiting for a connection
  - routeToPool
```
protected final java.util.Map<HttpRoute,RouteSpecificPool> routeToPool
```
    已过时。
    
    Map of route-specific pools
  - shutdown
```
protected volatile boolean shutdown
```
    已过时。
  - maxTotalConnections
```
protected volatile int maxTotalConnections
```
    已过时。
  - numConnections
```
protected volatile int numConnections
```
    已过时。
- 构造器详细资料
  - ConnPoolByRoute
```
public ConnPoolByRoute(ClientConnectionOperator operator,
               ConnPerRoute connPerRoute,
               int maxTotalConnections)
```
    已过时。
    
    Creates a new connection pool, managed by route.
    
    从以下版本开始:
    
    4.1
  - ConnPoolByRoute
```
public ConnPoolByRoute(ClientConnectionOperator operator,
               ConnPerRoute connPerRoute,
               int maxTotalConnections,
               long connTTL,
               java.util.concurrent.TimeUnit connTTLTimeUnit)
```
    已过时。
    
    从以下版本开始:
    
    4.1
  - ConnPoolByRoute
```
public ConnPoolByRoute(ClientConnectionOperator operator,
               HttpParams params)
```
    已过时。 (4.1) use ConnPoolByRoute(ClientConnectionOperator, ConnPerRoute, int)
    
    Creates a new connection pool, managed by route.
- 方法详细资料
  - getLock
```
protected java.util.concurrent.locks.Lock getLock()
```
    已过时。
  - createFreeConnQueue
```
protected java.util.Queue<BasicPoolEntry> createFreeConnQueue()
```
    已过时。
    
    Creates the queue for freeConnections. Called once by the constructor.
    
    返回:
    a queue
  - createWaitingThreadQueue
```
protected java.util.Queue<WaitingThread> createWaitingThreadQueue()
```
    已过时。
    
    Creates the queue for waitingThreads. Called once by the constructor.
    
    返回:
    a queue
  - createRouteToPoolMap
```
protected java.util.Map<HttpRoute,RouteSpecificPool> createRouteToPoolMap()
```
    已过时。
    
    Creates the map for routeToPool. Called once by the constructor.
    
    返回:
    a map
  - newRouteSpecificPool
```
protected RouteSpecificPool newRouteSpecificPool(HttpRoute route)
```
    已过时。
    
    Creates a new route-specific pool. Called by getRoutePool(depends.org.apache.http.conn.routing.HttpRoute, boolean) when necessary.
    
    参数:
    route - the route
    
    返回:
    the new pool
  - newWaitingThread
```
protected WaitingThread newWaitingThread(java.util.concurrent.locks.Condition cond,
                             RouteSpecificPool rospl)
```
    已过时。
    
    Creates a new waiting thread. Called by getRoutePool(depends.org.apache.http.conn.routing.HttpRoute, boolean) when necessary.
    
    参数:
    cond - the condition to wait for
    rospl - the route specific pool, or null
    
    返回:
    a waiting thread representation
  - getRoutePool
```
protected RouteSpecificPool getRoutePool(HttpRoute route,
                             boolean create)
```
    已过时。
    
    Get a route-specific pool of available connections.
    
    参数:
    route - the route
    create - whether to create the pool if it doesn't exist
    
    返回:
    the pool for the argument route, never null if create is true
  - getConnectionsInPool
```
public int getConnectionsInPool(HttpRoute route)
```
    已过时。
  - getConnectionsInPool
```
public int getConnectionsInPool()
```
    已过时。
  - requestPoolEntry
```
public PoolEntryRequest requestPoolEntry(HttpRoute route,
                                java.lang.Object state)
```
    已过时。
    
    从类复制的说明: AbstractConnPool
    
    Returns a new PoolEntryRequest, from which a BasicPoolEntry can be obtained, or the request can be aborted.
    
    指定者:
    
    requestPoolEntry 在类中 AbstractConnPool
  - getEntryBlocking
```
protected BasicPoolEntry getEntryBlocking(HttpRoute route,
                              java.lang.Object state,
                              long timeout,
                              java.util.concurrent.TimeUnit tunit,
                              WaitingThreadAborter aborter)
                                   throws ConnectionPoolTimeoutException,
                                          java.lang.InterruptedException
```
    已过时。
    
    Obtains a pool entry with a connection within the given timeout. If a WaitingThread is used to block, WaitingThreadAborter.setWaitingThread(WaitingThread) must be called before blocking, to allow the thread to be interrupted.
    
    参数:
    route - the route for which to get the connection
    timeout - the timeout, 0 or negative for no timeout
    tunit - the unit for the timeout, may be null only if there is no timeout
    aborter - an object which can abort a WaitingThread.
    
    返回:
    pool entry holding a connection for the route
    
    抛出:
    
    ConnectionPoolTimeoutException - if the timeout expired
    
    java.lang.InterruptedException - if the calling thread was interrupted
  - freeEntry
```
public void freeEntry(BasicPoolEntry entry,
             boolean reusable,
             long validDuration,
             java.util.concurrent.TimeUnit timeUnit)
```
    已过时。
    
    从类复制的说明: AbstractConnPool
    
    Returns an entry into the pool. The connection of the entry is expected to be in a suitable state, either open and re-usable, or closed. The pool will not make any attempt to determine whether it can be re-used or not.
    
    指定者:
    
    freeEntry 在类中 AbstractConnPool
    
    参数:
    entry - the entry for the connection to release
    reusable - true if the entry is deemed reusable, false otherwise.
    validDuration - The duration that the entry should remain free and reusable.
    timeUnit - The unit of time the duration is measured in.
  - getFreeEntry
```
protected BasicPoolEntry getFreeEntry(RouteSpecificPool rospl,
                          java.lang.Object state)
```
    已过时。
    
    If available, get a free pool entry for a route.
    
    参数:
    rospl - the route-specific pool from which to get an entry
    
    返回:
    an available pool entry for the given route, or null if none is available
  - createEntry
```
protected BasicPoolEntry createEntry(RouteSpecificPool rospl,
                         ClientConnectionOperator op)
```
    已过时。
    
    Creates a new pool entry. This method assumes that the new connection will be handed out immediately.
    
    参数:
    rospl - the route-specific pool for which to create the entry
    op - the operator for creating a connection
    
    返回:
    the new pool entry for a new connection
  - deleteEntry
```
protected void deleteEntry(BasicPoolEntry entry)
```
    已过时。
    
    Deletes a given pool entry. This closes the pooled connection and removes all references, so that it can be GCed.
    Note: Does not remove the entry from the freeConnections list. It is assumed that the caller has already handled this step.
    
    参数:
    entry - the pool entry for the connection to delete
  - deleteLeastUsedEntry
```
protected void deleteLeastUsedEntry()
```
    已过时。
    
    Delete an old, free pool entry to make room for a new one. Used to replace pool entries with ones for a different route.
  - handleLostEntry
```
protected void handleLostEntry(HttpRoute route)
```
    已过时。
    
    指定者:
    
    handleLostEntry 在类中 AbstractConnPool
  - notifyWaitingThread
```
protected void notifyWaitingThread(RouteSpecificPool rospl)
```
    已过时。
    
    Notifies a waiting thread that a connection is available. This will wake a thread waiting in the specific route pool, if there is one. Otherwise, a thread in the connection pool will be notified.
    
    参数:
    rospl - the pool in which to notify, or null
  - deleteClosedConnections
```
public void deleteClosedConnections()
```
    已过时。
    
    从类复制的说明: AbstractConnPool
    
    Deletes all entries for closed connections.
    
    指定者:
    
    deleteClosedConnections 在类中 AbstractConnPool
  - closeIdleConnections
```
public void closeIdleConnections(long idletime,
                        java.util.concurrent.TimeUnit tunit)
```
    已过时。
    
    Closes idle connections.
    
    覆盖:
    
    closeIdleConnections 在类中 AbstractConnPool
    
    参数:
    idletime - the time the connections should have been idle in order to be closed now
    tunit - the unit for the idletime
  - closeExpiredConnections
```
public void closeExpiredConnections()
```
    已过时。
    
    覆盖:
    
    closeExpiredConnections 在类中 AbstractConnPool
  - shutdown
```
public void shutdown()
```
    已过时。
    
    从类复制的说明: AbstractConnPool
    
    Shuts down this pool and all associated resources. Overriding methods MUST call the implementation here!
    
    覆盖:
    
    shutdown 在类中 AbstractConnPool
  - setMaxTotalConnections
```
public void setMaxTotalConnections(int max)
```
    已过时。
    
    since 4.1
  - getMaxTotalConnections
```
public int getMaxTotalConnections()
```
    已过时。
    
    since 4.1

类 ConnPoolByRoute

字段概要

从类继承的字段 depends.org.apache.http.impl.conn.tsccm.AbstractConnPool

构造器概要

方法概要

从类继承的方法 depends.org.apache.http.impl.conn.tsccm.AbstractConnPool

从类继承的方法 java.lang.Object

字段详细资料

operator

connPerRoute

leasedConnections

freeConnections

waitingThreads

routeToPool

shutdown

maxTotalConnections

numConnections

构造器详细资料

ConnPoolByRoute

ConnPoolByRoute

ConnPoolByRoute

方法详细资料

getLock

createFreeConnQueue

createWaitingThreadQueue

createRouteToPoolMap

newRouteSpecificPool

newWaitingThread

getRoutePool

getConnectionsInPool

getConnectionsInPool

requestPoolEntry

getEntryBlocking

freeEntry

getFreeEntry

createEntry

deleteEntry

deleteLeastUsedEntry

handleLostEntry

notifyWaitingThread

deleteClosedConnections

closeIdleConnections

closeExpiredConnections

shutdown

setMaxTotalConnections

getMaxTotalConnections