Package org.apache.hc.core5.pool

Class RouteSegmentedConnPool<R,C extends ModalCloseable>

java.lang.Object

org.apache.hc.core5.pool.RouteSegmentedConnPool<R,C>

Type Parameters:

R - route key type

C - connection type (must be ModalCloseable)

All Implemented Interfaces:

java.io.Closeable, java.lang.AutoCloseable, ModalCloseable, ConnPool<R,C>, ConnPoolControl<R>, ConnPoolStats<R>, ManagedConnPool<R,C>

@Contract(threading=SAFE_CONDITIONAL)
@Experimental
public final class RouteSegmentedConnPool<R,C extends ModalCloseable>
extends java.lang.Object
implements ManagedConnPool<R,C>

Lock-free, route-segmented connection pool with tiny, conditional round-robin assistance.

Per-route state is kept in independent segments. Disposal of connections is offloaded to a bounded executor so slow closes do not block threads leasing on other routes. A minimal round-robin drainer is engaged only when there are many pending routes and there is global headroom; it never scans all routes.

Since:

5.4

See Also:

ManagedConnPool, PoolReusePolicy, DisposalCallback

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
(package private) class	RouteSegmentedConnPool.Segment
(package private) class	RouteSegmentedConnPool.Waiter

Field Summary

Fields

Modifier and Type	Field	Description
private java.util.concurrent.atomic.AtomicBoolean	closed
private java.util.concurrent.atomic.AtomicInteger	defaultMaxPerRoute
private DisposalCallback<C>	disposal
private java.util.concurrent.ThreadPoolExecutor	disposer	Dedicated executor for asynchronous, best-effort disposal.
private java.util.concurrent.atomic.AtomicBoolean	draining
private java.util.concurrent.ConcurrentHashMap<R,java.lang.Integer>	maxPerRoute
private java.util.concurrent.atomic.AtomicInteger	maxTotal
private java.util.concurrent.ConcurrentLinkedQueue<R>	pendingQueue
private java.util.concurrent.atomic.AtomicInteger	pendingRouteCount
private PoolReusePolicy	reusePolicy
private static int	RR_BUDGET
private static int	RR_MIN_PENDING_ROUTES
private java.util.concurrent.ConcurrentHashMap<R,RouteSegmentedConnPool.Segment>	segments
private java.util.concurrent.ScheduledExecutorService	timeouts
private TimeValue	timeToLive
private java.util.concurrent.atomic.AtomicInteger	totalAllocated

Constructor Summary

Constructors

Constructor	Description
RouteSegmentedConnPool(int defaultMaxPerRoute, int maxTotal, TimeValue timeToLive, PoolReusePolicy reusePolicy, DisposalCallback<C> disposal)

Method Summary

Modifier and Type	Method	Description
private void	cancelTimeout(RouteSegmentedConnPool.Waiter w)
void	close()
void	close(CloseMode closeMode)	Closes this process or endpoint and releases any system resources associated with it.
void	closeExpired()
void	closeIdle(TimeValue idleTime)
private boolean	compatible(java.lang.Object needed, java.lang.Object have)
private void	dequeueIfDrained(RouteSegmentedConnPool.Segment seg)
private void	discardAndDecr(PoolEntry<R,C> p, CloseMode mode)
private void	discardEntry(PoolEntry<R,C> p, CloseMode preferred)	Dispose a pool entry's connection asynchronously if possible; under pressure fall back to IMMEDIATE on caller.
private void	enqueueIfNeeded(R route, RouteSegmentedConnPool.Segment seg)
private void	ensureOpen()
int	getDefaultMaxPerRoute()
int	getMaxPerRoute(R route)
int	getMaxTotal()
java.util.Set<R>	getRoutes()
PoolStats	getStats(R route)
PoolStats	getTotalStats()
private boolean	handOffToCompatibleWaiter(PoolEntry<R,C> entry, RouteSegmentedConnPool.Segment seg)
private boolean	isPastTtl(PoolEntry<R,C> p)
java.util.concurrent.Future<PoolEntry<R,C>>	lease(R route, java.lang.Object state, Timeout requestTimeout, FutureCallback<PoolEntry<R,C>> callback)	Attempts to lease a connection for the given route and with the given state from the pool.
private void	maybeCleanupSegment(R route, RouteSegmentedConnPool.Segment seg)
private void	offerAvailable(RouteSegmentedConnPool.Segment seg, PoolEntry<R,C> p)
private CloseMode	orImmediate(CloseMode m)
private PoolEntry<R,C>	pollAvailable(RouteSegmentedConnPool.Segment seg, java.lang.Object neededState)
void	release(PoolEntry<R,C> entry, boolean reusable)	Releases the pool entry back to the pool.
private void	scheduleTimeout(RouteSegmentedConnPool.Waiter w, RouteSegmentedConnPool.Segment seg)
private void	serveRoundRobin(int budget)
void	setDefaultMaxPerRoute(int max)
void	setMaxPerRoute(R route, int max)
void	setMaxTotal(int max)
private void	triggerDrainIfMany()
private boolean	tryAllocateOne(R route, RouteSegmentedConnPool.Segment seg)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

RR_MIN_PENDING_ROUTES

private static final int RR_MIN_PENDING_ROUTES

See Also:

Constant Field Values

RR_BUDGET

private static final int RR_BUDGET

See Also:

Constant Field Values

reusePolicy

private final PoolReusePolicy reusePolicy

timeToLive

private final TimeValue timeToLive

disposal

private final DisposalCallback<C extends ModalCloseable> disposal

defaultMaxPerRoute

private final java.util.concurrent.atomic.AtomicInteger defaultMaxPerRoute

segments

private final java.util.concurrent.ConcurrentHashMap<R,RouteSegmentedConnPool.Segment> segments

maxPerRoute

private final java.util.concurrent.ConcurrentHashMap<R,java.lang.Integer> maxPerRoute

totalAllocated

private final java.util.concurrent.atomic.AtomicInteger totalAllocated

maxTotal

private final java.util.concurrent.atomic.AtomicInteger maxTotal

closed

private final java.util.concurrent.atomic.AtomicBoolean closed

timeouts

private final java.util.concurrent.ScheduledExecutorService timeouts

disposer

private final java.util.concurrent.ThreadPoolExecutor disposer

Dedicated executor for asynchronous, best-effort disposal. Bounded queue; on saturation we fall back to IMMEDIATE close on the caller thread.

pendingQueue

private final java.util.concurrent.ConcurrentLinkedQueue<R> pendingQueue

draining

private final java.util.concurrent.atomic.AtomicBoolean draining

pendingRouteCount

private final java.util.concurrent.atomic.AtomicInteger pendingRouteCount

Constructor Detail

RouteSegmentedConnPool

public RouteSegmentedConnPool(int defaultMaxPerRoute,
                              int maxTotal,
                              TimeValue timeToLive,
                              PoolReusePolicy reusePolicy,
                              DisposalCallback<C> disposal)

Method Detail

lease

public java.util.concurrent.Future<PoolEntry<R,C>> lease(R route,
                                                               java.lang.Object state,
                                                               Timeout requestTimeout,
                                                               FutureCallback<PoolEntry<R,C>> callback)

Description copied from interface: ConnPool

Attempts to lease a connection for the given route and with the given state from the pool.

Please note the connection request can get automatically cancelled by the pool in case of a request timeout.

Specified by:

lease in interface ConnPool<R,C extends ModalCloseable>

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.

requestTimeout - request timeout. In case of a timeout the request can get automatically cancelled by the pool.

callback - operation completion callback.

Returns:

future for a leased pool entry.

release

public void release(PoolEntry<R,C> entry,
                    boolean reusable)

Description copied from interface: ConnPool

Releases the pool entry back to the pool.

Specified by:

release in interface ConnPool<R,C extends ModalCloseable>

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.

close

public void close()
           throws java.io.IOException

Specified by:

close in interface java.lang.AutoCloseable

Specified by:

close in interface java.io.Closeable

Throws:

java.io.IOException

close

public void close(CloseMode closeMode)

Description copied from interface: ModalCloseable

Closes this process or endpoint and releases any system resources associated with it. If the endpoint or the process is already closed then invoking this method has no effect.

Specified by:

close in interface ModalCloseable

Parameters:

closeMode - How to close the receiver.

closeIdle

public void closeIdle(TimeValue idleTime)

Specified by:

closeIdle in interface ConnPoolControl<R>

closeExpired

public void closeExpired()

Specified by:

closeExpired in interface ConnPoolControl<R>

getRoutes

public java.util.Set<R> getRoutes()

Specified by:

getRoutes in interface ConnPoolControl<R>

getMaxTotal

public int getMaxTotal()

Specified by:

getMaxTotal in interface ConnPoolControl<R>

setMaxTotal

public void setMaxTotal(int max)

Specified by:

setMaxTotal in interface ConnPoolControl<R>

getDefaultMaxPerRoute

public int getDefaultMaxPerRoute()

Specified by:

getDefaultMaxPerRoute in interface ConnPoolControl<R>

setDefaultMaxPerRoute

public void setDefaultMaxPerRoute(int max)

Specified by:

setDefaultMaxPerRoute in interface ConnPoolControl<R>

getMaxPerRoute

public int getMaxPerRoute(R route)

Specified by:

getMaxPerRoute in interface ConnPoolControl<R>

setMaxPerRoute

public void setMaxPerRoute(R route,
                           int max)

Specified by:

setMaxPerRoute in interface ConnPoolControl<R>

getTotalStats

public PoolStats getTotalStats()

Specified by:

getTotalStats in interface ConnPoolStats<R>

getStats

public PoolStats getStats(R route)

Specified by:

getStats in interface ConnPoolStats<R>

ensureOpen

private void ensureOpen()

isPastTtl

private boolean isPastTtl(PoolEntry<R,C> p)

scheduleTimeout

private void scheduleTimeout(RouteSegmentedConnPool.Waiter w,
                             RouteSegmentedConnPool.Segment seg)

cancelTimeout

private void cancelTimeout(RouteSegmentedConnPool.Waiter w)

offerAvailable

private void offerAvailable(RouteSegmentedConnPool.Segment seg,
                            PoolEntry<R,C> p)

pollAvailable

private PoolEntry<R,C> pollAvailable(RouteSegmentedConnPool.Segment seg,
                                           java.lang.Object neededState)

compatible

private boolean compatible(java.lang.Object needed,
                           java.lang.Object have)

handOffToCompatibleWaiter

private boolean handOffToCompatibleWaiter(PoolEntry<R,C> entry,
                                          RouteSegmentedConnPool.Segment seg)

discardAndDecr

private void discardAndDecr(PoolEntry<R,C> p,
                            CloseMode mode)

orImmediate

private CloseMode orImmediate(CloseMode m)

maybeCleanupSegment

private void maybeCleanupSegment(R route,
                                 RouteSegmentedConnPool.Segment seg)

tryAllocateOne

private boolean tryAllocateOne(R route,
                               RouteSegmentedConnPool.Segment seg)

enqueueIfNeeded

private void enqueueIfNeeded(R route,
                             RouteSegmentedConnPool.Segment seg)

dequeueIfDrained

private void dequeueIfDrained(RouteSegmentedConnPool.Segment seg)

triggerDrainIfMany

private void triggerDrainIfMany()

serveRoundRobin

private void serveRoundRobin(int budget)

discardEntry

private void discardEntry(PoolEntry<R,C> p,
                          CloseMode preferred)

Dispose a pool entry's connection asynchronously if possible; under pressure fall back to IMMEDIATE on caller.