Class AbstractConnectionPool

java.lang.Object
org.eclipse.jetty.util.component.AbstractLifeCycle
org.eclipse.jetty.util.component.ContainerLifeCycle
org.eclipse.jetty.client.AbstractConnectionPool
All Implemented Interfaces:
Closeable, AutoCloseable, ConnectionPool, Container, Destroyable, Dumpable, Dumpable.DumpableContainer, LifeCycle, Sweeper.Sweepable
Direct Known Subclasses:
DuplexConnectionPool, MultiplexConnectionPool
@ManagedObject public abstract class AbstractConnectionPool extends ContainerLifeCycle implements ConnectionPool, Dumpable, Sweeper.Sweepable

  • Field Details

    • LOG

      private static final Logger LOG

    • pending

      private final AtomicInteger pending

    • destination

      private final HttpDestination destination

    • requester

      private final Callback requester

    • pool

      private final Pool<Connection> pool

    • maximizeConnections

      private boolean maximizeConnections

    • maxDurationNanos

      private volatile long maxDurationNanos

  • Constructor Details

  • Method Details

    • doStop

      protected void doStop() throws Exception
      Description copied from class: ContainerLifeCycle
      Stops the managed lifecycle beans in the reverse order they were added.
      Overrides:
      doStop in class ContainerLifeCycle
      Throws:
      Exception

    • preCreateConnections

      public CompletableFuture<Void> preCreateConnections(int connectionCount)
      Description copied from interface: ConnectionPool
      Optionally pre-create up to connectionCount connections so they are immediately ready for use.
      Specified by:
      preCreateConnections in interface ConnectionPool
      Parameters:
      connectionCount - the number of connections to pre-start.

    • getMaxDuration

      @ManagedAttribute("The maximum duration in milliseconds a connection can be used for before it gets closed") public long getMaxDuration()

      Get the max usage duration in milliseconds of the pool's connections. Values 0 and negative mean that there is no limit.

      This only guarantees that a connection cannot be acquired after the configured duration elapses, so that is only enforced when acquire() is called. If a pool stays completely idle for a duration longer than the value returned by this method, the max duration will not be enforced. It's up to the idle timeout mechanism (see HttpClient.getIdleTimeout()) to handle closing idle connections.

    • setMaxDuration

      public void setMaxDuration(long maxDurationInMs)

    • getMaxMultiplex

      protected int getMaxMultiplex()

    • setMaxMultiplex

      protected void setMaxMultiplex(int maxMultiplex)

    • getMaxUsageCount

      protected int getMaxUsageCount()

    • setMaxUsageCount

      protected void setMaxUsageCount(int maxUsageCount)

    • getActiveConnectionCount

      @ManagedAttribute(value="The number of active connections", readonly=true) public int getActiveConnectionCount()

    • getIdleConnectionCount

      @ManagedAttribute(value="The number of idle connections", readonly=true) public int getIdleConnectionCount()

    • getMaxConnectionCount

      @ManagedAttribute(value="The max number of connections", readonly=true) public int getMaxConnectionCount()

    • getConnectionCount

      @ManagedAttribute(value="The number of connections", readonly=true) public int getConnectionCount()

    • getPendingCount

      @ManagedAttribute(value="The number of pending connections", readonly=true) @Deprecated public int getPendingCount()
      Deprecated.
      use getPendingConnectionCount() instead
      Returns:
      the number of pending connections

    • getPendingConnectionCount

      @ManagedAttribute(value="The number of pending connections", readonly=true) public int getPendingConnectionCount()

    • isEmpty

      public boolean isEmpty()
      Specified by:
      isEmpty in interface ConnectionPool
      Returns:
      whether this ConnectionPool has no open connections

    • isClosed

      @ManagedAttribute("Whether this pool is closed") public boolean isClosed()
      Specified by:
      isClosed in interface ConnectionPool
      Returns:
      whether this ConnectionPool has been closed
      See Also:

    • isMaximizeConnections

      @ManagedAttribute("Whether the pool tries to maximize the number of connections used") public boolean isMaximizeConnections()

    • setMaximizeConnections

      public void setMaximizeConnections(boolean maximizeConnections)

      Sets whether the number of connections should be maximized.

      Parameters:
      maximizeConnections - whether the number of connections should be maximized

    • acquire

      public Connection acquire()
      Description copied from interface: ConnectionPool

      Returns an idle connection, if available, or schedules the opening of a new connection and returns null.

      Specified by:
      acquire in interface ConnectionPool
      Returns:
      an available connection, or null

    • acquire

      protected Connection acquire(boolean create)

      Returns an idle connection, if available; if an idle connection is not available, and the given create parameter is true or isMaximizeConnections() is true, then attempts to open a new connection, if possible within the configuration of this connection pool (for example, if it does not exceed the max connection count); otherwise it attempts to open a new connection, if the number of queued requests is greater than the number of pending connections; if no connection is available even after the attempts to open, return null.

      The create parameter is just a hint: the connection may be created even if false, or may not be created even if true.

      Parameters:
      create - a hint to attempt to open a new connection if no idle connections are available
      Returns:
      an idle connection or null if no idle connections are available
      See Also:

    • tryCreate

      protected void tryCreate(boolean create)

      Tries to create a new connection.

      Whether a new connection is created is determined by the create parameter and a count of demand and supply, where the demand is derived from the number of queued requests, and the supply is the number of pending connections time the getMaxMultiplex() factor: if the demand is less than the supply, the connection will not be created.

      Since the number of queued requests used to derive the demand may be a stale value, it is possible that few more connections than strictly necessary may be created, but enough to satisfy the demand.

      Parameters:
      create - a hint to request to create a connection

    • proceed

      protected void proceed()

    • activate

      protected Connection activate()

    • isActive

      public boolean isActive(Connection connection)
      Specified by:
      isActive in interface ConnectionPool
      Parameters:
      connection - the connection to test
      Returns:
      whether the given connection is currently in use

    • release

      public boolean release(Connection connection)
      Description copied from interface: ConnectionPool

      Returns the given connection, previously obtained via ConnectionPool.acquire(), back to this ConnectionPool.

      Specified by:
      release in interface ConnectionPool
      Parameters:
      connection - the connection to release
      Returns:
      true if the connection has been released, false if the connection should be closed

    • deactivate

      protected boolean deactivate(Connection connection)

    • remove

      public boolean remove(Connection connection)
      Description copied from interface: ConnectionPool

      Removes the given connection from this ConnectionPool.

      Specified by:
      remove in interface ConnectionPool
      Parameters:
      connection - the connection to remove
      Returns:
      true if the connection was removed from this ConnectionPool

    • remove

      protected boolean remove(Connection connection, boolean force)

    • onCreated

      protected void onCreated(Connection connection)

    • idle

      protected boolean idle(Connection connection, boolean close)

    • acquired

      protected void acquired(Connection connection)

    • released

      protected void released(Connection connection)

    • removed

      protected void removed(Connection connection)

    • getIdleConnections

      @Deprecated public Queue<Connection> getIdleConnections()
      Deprecated.
      Relying on this method indicates a reliance on the implementation details.
      Returns:
      an unmodifiable queue working as a view of the idle connections.

    • getActiveConnections

      @Deprecated public Collection<Connection> getActiveConnections()
      Deprecated.
      Relying on this method indicates a reliance on the implementation details.
      Returns:
      an unmodifiable collection working as a view of the active connections.

    • close

      public void close()
      Description copied from interface: ConnectionPool
      Closes this ConnectionPool.
      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in interface Closeable
      Specified by:
      close in interface ConnectionPool
      See Also:

    • dump

      public void dump(Appendable out, String indent) throws IOException
      Description copied from interface: Dumpable
      Dump this object (and children) into an Appendable using the provided indent after any new lines. The indent should not be applied to the first object dumped.
      Specified by:
      dump in interface Dumpable
      Overrides:
      dump in class ContainerLifeCycle
      Parameters:
      out - The appendable to dump to
      indent - The indent to apply after any new lines.
      Throws:
      IOException - if unable to write to Appendable

    • sweep

      public boolean sweep()
      Specified by:
      sweep in interface Sweeper.Sweepable
      Returns:
      whether this resource should be swept

    • toString

      public String toString()
      Overrides:
      toString in class AbstractLifeCycle