public class MultiEndpointPool<E> extends Object
Connection
pool implementation where each endpoint
sub-pool is represented by SingleEndpointPool
and referenced by an EndpointKey
.
There are number of configuration options supported by the MultiEndpointPool:
- maxConnectionsPerEndpoint: the maximum number of Connection
s each
SingleEndpointPool
sub-pool is allowed to have;
- maxConnectionsTotal: the total maximum number of Connection
s to be kept by the pool;
- keepAliveTimeoutMillis: the maximum number of milliseconds an idle Connection
will be kept in the pool. The idle Connection
s will be
closed until the pool size is greater than the corePoolSize;
- keepAliveCheckIntervalMillis: the interval, which specifies how often the pool will
perform idle Connection
s check;
- reconnectDelayMillis: the delay to be used before the pool will repeat the attempt to connect to
the endpoint after previous connect had failed.Modifier and Type | Class and Description |
---|---|
static class |
MultiEndpointPool.Builder<E>
The Builder class responsible for constructing
SingleEndpointPool . |
Modifier and Type | Field and Description |
---|---|
protected Map<EndpointKey<E>,SingleEndpointPool<E>> |
endpointToPoolMap
Maps endpoint -to- SingleEndpointPool
|
protected Object |
poolSync
Sync for endpointToPoolMap updates
|
Modifier | Constructor and Description |
---|---|
protected |
MultiEndpointPool(ConnectorHandler<E> defaultConnectorHandler,
int maxConnectionsPerEndpoint,
int maxConnectionsTotal,
DelayedExecutor delayedExecutor,
long connectTimeoutMillis,
long keepAliveTimeoutMillis,
long keepAliveCheckIntervalMillis,
long reconnectDelayMillis,
int maxReconnectAttempts)
Constructs MultiEndpointPool instance.
|
Modifier and Type | Method and Description |
---|---|
boolean |
attach(EndpointKey<E> endpointKey,
Connection connection)
Attaches "foreign"
Connection to the pool. |
static <T> MultiEndpointPool.Builder<T> |
builder(Class<T> endpointType)
Returns single endpoint pool
MultiEndpointPool.Builder . |
protected void |
checkNotClosed()
Method throws
IOException if the pool has been closed. |
void |
close()
Closes the pool and releases associated resources.
|
void |
close(EndpointKey<E> endpointKey)
Closes specific endpoint associated pool and releases its resources.
|
protected SingleEndpointPool<E> |
createSingleEndpointPool(EndpointKey<E> endpointKey)
Creates
SingleEndpointPool instance. |
boolean |
detach(Connection connection)
Detaches a
Connection from the pool. |
ConnectionInfo<E> |
getConnectionInfo(Connection connection)
Returns pooled
ConnectionInfo , that might be used for monitoring
reasons, or null if the Connection does not belong to
this pool. |
int |
getOpenConnectionsCount()
Returns the number of connected
Connection s in the pool. |
boolean |
isBusy(Connection connection)
Returns true only if the
Connection is registered in
the pool and is currently in busy state (used by a user), otherwise
returns false. |
boolean |
isMaxCapacityReached()
Returns true is maximum number of
Connection s the pool
can keep is reached and no new Connection can established, or
false otherwise. |
boolean |
isRegistered(Connection connection)
Returns true if the
Connection is registered in the pool
no matter if it's currently in busy or ready state, or false if
the Connection is not registered in the pool. |
protected SingleEndpointPool<E> |
obtainSingleEndpointPool(EndpointKey<E> endpointKey)
Obtains
SingleEndpointPool associated with the specific endpoint
represented by EndpointKey . |
boolean |
release(Connection connection)
Returns the
Connection to the pool. |
int |
size()
Returns the current pool size.
|
GrizzlyFuture<Connection> |
take(EndpointKey<E> endpointKey)
Obtains a
Connection to the specified endpoint from the pool in
non-blocking/asynchronous fashion. |
void |
take(EndpointKey<E> endpointKey,
CompletionHandler<Connection> completionHandler)
Obtains a
Connection to the specified endpoint from the pool
in non-blocking/asynchronous fashion. |
String |
toString() |
protected final Map<EndpointKey<E>,SingleEndpointPool<E>> endpointToPoolMap
protected final Object poolSync
protected MultiEndpointPool(ConnectorHandler<E> defaultConnectorHandler, int maxConnectionsPerEndpoint, int maxConnectionsTotal, DelayedExecutor delayedExecutor, long connectTimeoutMillis, long keepAliveTimeoutMillis, long keepAliveCheckIntervalMillis, long reconnectDelayMillis, int maxReconnectAttempts)
defaultConnectorHandler
- the default ConnectorHandler
to be used to establish new Connection
smaxConnectionsPerEndpoint
- the maximum number of Connection
s single endpoint sub-pool is allowed to havemaxConnectionsTotal
- the total maximum number of Connection
s the pool is allowed to havedelayedExecutor
- custom DelayedExecutor
to be used by keep-alive and reconnect mechanismsconnectTimeoutMillis
- timeout, after which, if a connection is not established, it is considered failedkeepAliveTimeoutMillis
- the maximum number of milliseconds an idle Connection
will be kept in the poolkeepAliveCheckIntervalMillis
- the interval, which specifies how often the pool will perform idle Connection
s checkreconnectDelayMillis
- the delay to be used before the pool will repeat the attempt to connect to the endpoint after previous connect had failedmaxReconnectAttempts
- the maximum number of reconnect attempts that may be made before failure notification.public static <T> MultiEndpointPool.Builder<T> builder(Class<T> endpointType)
MultiEndpointPool.Builder
.endpointType
- endpoint address type, for example
SocketAddress
for TCP and UDP transportsMultiEndpointPool.Builder
public int size()
Connection
s.public int getOpenConnectionsCount()
Connection
s in the pool.
Unlike size()
the value doesn't include connecting
(connect in progress) Connection
s.public boolean isMaxCapacityReached()
Connection
s the pool
can keep is reached and no new Connection
can established, or
false otherwise.public boolean isRegistered(Connection connection)
Connection
is registered in the pool
no matter if it's currently in busy or ready state, or false if
the Connection
is not registered in the pool.connection
- Connection
Connection
is registered in the pool
no matter if it's currently in busy or ready state, or false if
the Connection
is not registered in the poolpublic boolean isBusy(Connection connection)
Connection
is registered in
the pool and is currently in busy state (used by a user), otherwise
returns false.connection
- Connection
Connection
is registered in
the pool and is currently in busy state (used by a user), otherwise
returns falsepublic ConnectionInfo<E> getConnectionInfo(Connection connection)
ConnectionInfo
, that might be used for monitoring
reasons, or null if the Connection
does not belong to
this pool.connection
- Connection
ConnectionInfo
, that might be used for monitoring
reasons, or null if the Connection
does not belong to
this poolpublic GrizzlyFuture<Connection> take(EndpointKey<E> endpointKey)
Connection
to the specified endpoint from the pool in
non-blocking/asynchronous fashion.
Returns a GrizzlyFuture
representing the pending result of the
non-blocking/asynchronous obtain task.
Future's get method will return the Connection
once it
becomes available in the pool.
If you would like to immediately block waiting
for a Connection
, you can use constructions of the form
connection = pool.take(endpointKey).get();
Note: returned GrizzlyFuture
must be checked and released
properly. It must not be forgotten, because a Connection
, that
might be assigned as a result of GrizzlyFuture
has to be returned
to the pool. If you gave up on waiting for a Connection
or you
are not interested in the Connection
anymore, the proper release
code has to look like:
if (!future.cancel(false)) { // means Connection is ready pool.release(future.get()); }
endpointKey
- EndpointKey
, that represents an endpointGrizzlyFuture
public void take(EndpointKey<E> endpointKey, CompletionHandler<Connection> completionHandler)
Connection
to the specified endpoint from the pool
in non-blocking/asynchronous fashion.
The passed CompletionHandler
will be notified about the result of the
non-blocking/asynchronous obtain task.endpointKey
- EndpointKey
, that represents an endpointpublic boolean release(Connection connection)
Connection
to the pool.
The Connection
will be returned to the pool only in case it
was created by this pool, or it was attached to it using attach(EndpointKey, org.glassfish.grizzly.Connection)
method.
If the Connection
is not registered in the pool - it will be closed.
If the Connection
is registered in the pool and already marked as ready - this method call will not have any effect.
If the Connection
was returned - it is illegal to use it until
it is retrieved from the pool again.connection
- the Connection
to returntrue
if the connection was successfully released.
If the connection cannot be released, the connection will be closed
and false
will be returned.public boolean attach(EndpointKey<E> endpointKey, Connection connection) throws IOException
Connection
to the pool.
This method might be used to add to the pool a Connection
, that
either has not been created by this pool or has been detached.endpointKey
- EndpointKey
, that represents an endpoint to
which the the Connection
will be attachedconnection
- Connection
Connection
has been successfully attached,
or false otherwise. If the Connection
had
been already registered in the pool - the method call doesn't
have any effect and true will be returned.IOException
- thrown if this pool has been already closedpublic boolean detach(Connection connection)
Connection
from the pool.
De-registers the Connection
from the pool and decreases the pool
size by 1. It is possible to re-attach the detached Connection
later by calling attach(org.glassfish.grizzly.connectionpool.EndpointKey, org.glassfish.grizzly.Connection)
.
If the Connection
was not registered in the pool - the
method call doesn't have any effect.connection
- the Connection
to detachtrue
if the Connection
was detached, otherwise
returns false
public void close(EndpointKey<E> endpointKey)
Connection
s associated with the endpoint pool will be
closed, the busy Connection
, that are still in use - will be kept open and
will be automatically closed when returned to the pool by release(org.glassfish.grizzly.Connection)
.endpointKey
- EndpointKey
, that represents an endpointpublic void close()
Connection
s will be closed, the busy Connection
,
that are still in use - will be kept open and will be automatically
closed when returned to the pool by release(org.glassfish.grizzly.Connection)
.protected SingleEndpointPool<E> obtainSingleEndpointPool(EndpointKey<E> endpointKey) throws IOException
SingleEndpointPool
associated with the specific endpoint
represented by EndpointKey
. If there is no SingleEndpointPool
associated with the endpoint - the one will be created.endpointKey
- EndpointKey
, that represents an endpointSingleEndpointPool
IOException
- if the pool is already closedprotected SingleEndpointPool<E> createSingleEndpointPool(EndpointKey<E> endpointKey)
SingleEndpointPool
instance.endpointKey
- the endpoint keySingleEndpointPool
protected void checkNotClosed() throws IOException
IOException
if the pool has been closed.IOException
Copyright © 2014 Oracle Corporation. All rights reserved.