Package org.apache.http.impl.conn.tsccm

Class AbstractConnPool

java.lang.Object
org.apache.http.impl.conn.tsccm.AbstractConnPool
All Implemented Interfaces:
RefQueueHandler
Direct Known Subclasses:
ConnPoolByRoute
public abstract class AbstractConnPool
extends Object
implements RefQueueHandler
An abstract connection pool. It is used by the ThreadSafeClientConnManager. The abstract pool includes a poolLock, which is used to synchronize access to the internal pool datastructures. Don't use synchronized for that purpose!

  • Field Details

    • poolLock

      protected final Lock poolLock
      The global lock for this pool.

    • issuedConnections

      protected Set<BasicPoolEntryRef> issuedConnections
      References to issued connections. Objects in this set are of class BasicPoolEntryRef, and point to the pool entry for the issued connection. GCed connections are detected by the missing pool entries.

    • idleConnHandler

      protected IdleConnectionHandler idleConnHandler
      The handler for idle connections.

    • numConnections

      protected int numConnections
      The current total number of connections.

    • refQueue

      protected ReferenceQueue<Object> refQueue
      A reference queue to track loss of pool entries to GC. The same queue is used to track loss of the connection manager, so we cannot specialize the type.

    • isShutDown

      protected volatile boolean isShutDown
      Indicates whether this pool is shut down.

  • Constructor Details

    • AbstractConnPool

      protected AbstractConnPool()
      Creates a new connection pool.

  • Method Details

    • enableConnectionGC

      public void enableConnectionGC() throws IllegalStateException
      Enables connection garbage collection (GC). This method must be called immediately after creating the connection pool. It is not possible to enable connection GC after pool entries have been created. Neither is it possible to disable connection GC.
      Throws:
      IllegalStateException - if connection GC is already enabled, or if it cannot be enabled because there already are pool entries

    • getEntry

      public final BasicPoolEntry getEntry​(HttpRoute route, Object state, long timeout, TimeUnit tunit) throws ConnectionPoolTimeoutException, InterruptedException
      Obtains a pool entry with a connection within the given timeout.
      Parameters:
      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
      Returns:
      pool entry holding a connection for the route
      Throws:
      ConnectionPoolTimeoutException - if the timeout expired
      InterruptedException - if the calling thread was interrupted

    • requestPoolEntry

      public abstract PoolEntryRequest requestPoolEntry​(HttpRoute route, Object state)
      Returns a new PoolEntryRequest, from which a BasicPoolEntry can be obtained, or the request can be aborted.

    • freeEntry

      public abstract void freeEntry​(BasicPoolEntry entry, boolean reusable, long validDuration, TimeUnit timeUnit)
      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.
      Parameters:
      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.

    • handleReference

      public void handleReference​(Reference ref)
      Description copied from interface: RefQueueHandler
      Invoked when a reference is found on the queue.
      Specified by:
      handleReference in interface RefQueueHandler
      Parameters:
      ref - the reference to handle

    • handleLostEntry

      protected abstract void handleLostEntry​(HttpRoute route)
      Handles cleaning up for a lost pool entry with the given route. A lost pool entry corresponds to a connection that was garbage collected instead of being properly released.
      Parameters:
      route - the route of the pool entry that was lost

    • closeIdleConnections

      public void closeIdleConnections​(long idletime, TimeUnit tunit)
      Closes idle connections.
      Parameters:
      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()

    • deleteClosedConnections

      public abstract void deleteClosedConnections()
      Deletes all entries for closed connections.

    • shutdown

      public void shutdown()
      Shuts down this pool and all associated resources. Overriding methods MUST call the implementation here!

    • closeConnection

      protected void closeConnection​(OperatedClientConnection conn)
      Closes a connection from this pool.
      Parameters:
      conn - the connection to close, or null