SimpleChannelPool

java.lang.Object
- io.netty.channel.pool.SimpleChannelPool

All Implemented Interfaces:

ChannelPool, java.io.Closeable, java.lang.AutoCloseable

Direct Known Subclasses:

FixedChannelPool
```
public class SimpleChannelPool
extends java.lang.Object
implements ChannelPool
```
Simple ChannelPool implementation which will create new Channels if someone tries to acquire a Channel but none is in the pool atm. No limit on the maximal concurrent Channels is enforced. This implementation uses LIFO order for Channels in the ChannelPool.

Field Summary

Fields
Modifier and Type	Field and Description
`private Bootstrap`	`bootstrap`
`private java.util.Deque<Channel>`	`deque`
`private static java.lang.IllegalStateException`	`FULL_EXCEPTION`
`private ChannelPoolHandler`	`handler`
`private ChannelHealthChecker`	`healthCheck`
`private static AttributeKey<SimpleChannelPool>`	`POOL_KEY`
`private boolean`	`releaseHealthCheck`
`private static java.lang.IllegalStateException`	`UNHEALTHY_NON_OFFERED_TO_POOL`

Constructor Summary

Constructors
Constructor and Description
`SimpleChannelPool(Bootstrap bootstrap, ChannelPoolHandler handler)` Creates a new instance using the `ChannelHealthChecker.ACTIVE`.
`SimpleChannelPool(Bootstrap bootstrap, ChannelPoolHandler handler, ChannelHealthChecker healthCheck)` Creates a new instance.
`SimpleChannelPool(Bootstrap bootstrap, ChannelPoolHandler handler, ChannelHealthChecker healthCheck, boolean releaseHealthCheck)` Creates a new instance.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Future<Channel>`	`acquire()` Acquire a `Channel` from this `ChannelPool`.
`Future<Channel>`	`acquire(Promise<Channel> promise)` Acquire a `Channel` from this `ChannelPool`.
`private Future<Channel>`	`acquireHealthyFromPoolOrNew(Promise<Channel> promise)` Tries to retrieve healthy channel from the pool if any or creates a new channel otherwise.
`void`	`close()`
`private static void`	`closeAndFail(Channel channel, java.lang.Throwable cause, Promise<?> promise)`
`private static void`	`closeChannel(Channel channel)`
`protected ChannelFuture`	`connectChannel(Bootstrap bs)` Bootstrap a new `Channel`.
`private void`	`doHealthCheck(Channel ch, Promise<Channel> promise)`
`private void`	`doHealthCheckOnRelease(Channel channel, Promise<java.lang.Void> promise)`
`private void`	`doReleaseChannel(Channel channel, Promise<java.lang.Void> promise)`
`private void`	`notifyConnect(ChannelFuture future, Promise<Channel> promise)`
`private void`	`notifyHealthCheck(Future<java.lang.Boolean> future, Channel ch, Promise<Channel> promise)`
`protected boolean`	`offerChannel(Channel channel)` Offer a `Channel` back to the internal storage.
`protected Channel`	`pollChannel()` Poll a `Channel` out of the internal storage to reuse it.
`Future<java.lang.Void>`	`release(Channel channel)` Release a `Channel` back to this `ChannelPool`.
`Future<java.lang.Void>`	`release(Channel channel, Promise<java.lang.Void> promise)` Release a `Channel` back to this `ChannelPool`.
`private void`	`releaseAndOffer(Channel channel, Promise<java.lang.Void> promise)`
`private void`	`releaseAndOfferIfHealthy(Channel channel, Promise<java.lang.Void> promise, Future<java.lang.Boolean> future)` Adds the channel back to the pool only if the channel is healty.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - POOL_KEY
```
private static final AttributeKey<SimpleChannelPool> POOL_KEY
```
  - FULL_EXCEPTION
```
private static final java.lang.IllegalStateException FULL_EXCEPTION
```
  - UNHEALTHY_NON_OFFERED_TO_POOL
```
private static final java.lang.IllegalStateException UNHEALTHY_NON_OFFERED_TO_POOL
```
  - deque
```
private final java.util.Deque<Channel> deque
```
  - handler
```
private final ChannelPoolHandler handler
```
  - healthCheck
```
private final ChannelHealthChecker healthCheck
```
  - bootstrap
```
private final Bootstrap bootstrap
```
  - releaseHealthCheck
```
private final boolean releaseHealthCheck
```
- Constructor Detail
  - SimpleChannelPool
```
public SimpleChannelPool(Bootstrap bootstrap,
                         ChannelPoolHandler handler)
```
    Creates a new instance using the ChannelHealthChecker.ACTIVE.
    
    Parameters:
    
    bootstrap - the Bootstrap that is used for connections
    
    handler - the ChannelPoolHandler that will be notified for the different pool actions
  - SimpleChannelPool
```
public SimpleChannelPool(Bootstrap bootstrap,
                         ChannelPoolHandler handler,
                         ChannelHealthChecker healthCheck)
```
    Creates a new instance.
    
    Parameters:
    
    bootstrap - the Bootstrap that is used for connections
    
    handler - the ChannelPoolHandler that will be notified for the different pool actions
    
    healthCheck - the ChannelHealthChecker that will be used to check if a Channel is still healthy when obtain from the ChannelPool
  - SimpleChannelPool
```
public SimpleChannelPool(Bootstrap bootstrap,
                         ChannelPoolHandler handler,
                         ChannelHealthChecker healthCheck,
                         boolean releaseHealthCheck)
```
    Creates a new instance.
    
    Parameters:
    
    bootstrap - the Bootstrap that is used for connections
    
    handler - the ChannelPoolHandler that will be notified for the different pool actions
    
    healthCheck - the ChannelHealthChecker that will be used to check if a Channel is still healthy when obtain from the ChannelPool
    
    releaseHealthCheck - will offercheck channel health before offering back if this parameter set to true.
- Method Detail
  - acquire
```
public final Future<Channel> acquire()
```
    Description copied from interface: ChannelPool
    
    Acquire a Channel from this ChannelPool. The returned Future is notified once the acquire is successful and failed otherwise. Its important that an acquired is always released to the pool again, even if the Channel is explicitly closed..
    
    Specified by:
    
    acquire in interface ChannelPool
  - acquire
```
public Future<Channel> acquire(Promise<Channel> promise)
```
    Description copied from interface: ChannelPool
    
    Acquire a Channel from this ChannelPool. The given Promise is notified once the acquire is successful and failed otherwise. Its important that an acquired is always released to the pool again, even if the Channel is explicitly closed..
    
    Specified by:
    
    acquire in interface ChannelPool
  - acquireHealthyFromPoolOrNew
```
private Future<Channel> acquireHealthyFromPoolOrNew(Promise<Channel> promise)
```
    Tries to retrieve healthy channel from the pool if any or creates a new channel otherwise.
    
    Parameters:
    
    promise - the promise to provide acquire result.
    
    Returns:
    
    future for acquiring a channel.
  - notifyConnect
```
private void notifyConnect(ChannelFuture future,
                           Promise<Channel> promise)
```
  - doHealthCheck
```
private void doHealthCheck(Channel ch,
                           Promise<Channel> promise)
```
  - notifyHealthCheck
```
private void notifyHealthCheck(Future<java.lang.Boolean> future,
                               Channel ch,
                               Promise<Channel> promise)
```
  - connectChannel
```
protected ChannelFuture connectChannel(Bootstrap bs)
```
    Bootstrap a new Channel. The default implementation uses Bootstrap.connect(), sub-classes may override this.
    The Bootstrap that is passed in here is cloned via Bootstrap.clone(), so it is safe to modify.
  - release
```
public final Future<java.lang.Void> release(Channel channel)
```
    Description copied from interface: ChannelPool
    
    Release a Channel back to this ChannelPool. The returned Future is notified once the release is successful and failed otherwise. When failed the Channel will automatically closed.
    
    Specified by:
    
    release in interface ChannelPool
  - release
```
public Future<java.lang.Void> release(Channel channel,
                                      Promise<java.lang.Void> promise)
```
    Description copied from interface: ChannelPool
    
    Release a Channel back to this ChannelPool. The given Promise is notified once the release is successful and failed otherwise. When failed the Channel will automatically closed.
    
    Specified by:
    
    release in interface ChannelPool
  - doReleaseChannel
```
private void doReleaseChannel(Channel channel,
                              Promise<java.lang.Void> promise)
```
  - doHealthCheckOnRelease
```
private void doHealthCheckOnRelease(Channel channel,
                                    Promise<java.lang.Void> promise)
                             throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - releaseAndOfferIfHealthy
```
private void releaseAndOfferIfHealthy(Channel channel,
                                      Promise<java.lang.Void> promise,
                                      Future<java.lang.Boolean> future)
                               throws java.lang.Exception
```
    Adds the channel back to the pool only if the channel is healty.
    
    Parameters:
    
    channel - the channel to put back to the pool
    
    promise - offer operation promise.
    
    future - the future that contains information fif channel is healthy or not.
    
    Throws:
    
    java.lang.Exception - in case when failed to notify handler about release operation.
  - releaseAndOffer
```
private void releaseAndOffer(Channel channel,
                             Promise<java.lang.Void> promise)
                      throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - closeChannel
```
private static void closeChannel(Channel channel)
```
  - closeAndFail
```
private static void closeAndFail(Channel channel,
                                 java.lang.Throwable cause,
                                 Promise<?> promise)
```
  - pollChannel
```
protected Channel pollChannel()
```
    Poll a Channel out of the internal storage to reuse it. This will return null if no Channel is ready to be reused. Sub-classes may override pollChannel() and offerChannel(Channel). Be aware that implementations of these methods needs to be thread-safe!
  - offerChannel
```
protected boolean offerChannel(Channel channel)
```
    Offer a Channel back to the internal storage. This will return true if the Channel could be added, false otherwise. Sub-classes may override pollChannel() and offerChannel(Channel). Be aware that implementations of these methods needs to be thread-safe!
  - close
```
public void close()
```
    Specified by:
    
    close in interface ChannelPool
    
    Specified by:
    
    close in interface java.io.Closeable
    
    Specified by:
    
    close in interface java.lang.AutoCloseable

Class SimpleChannelPool

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

POOL_KEY

FULL_EXCEPTION

UNHEALTHY_NON_OFFERED_TO_POOL

deque

handler

healthCheck

bootstrap

releaseHealthCheck

Constructor Detail

SimpleChannelPool

SimpleChannelPool

SimpleChannelPool

Method Detail

acquire

acquire

acquireHealthyFromPoolOrNew

notifyConnect

doHealthCheck

notifyHealthCheck

connectChannel

release

release

doReleaseChannel

doHealthCheckOnRelease

releaseAndOfferIfHealthy

releaseAndOffer

closeChannel

closeAndFail

pollChannel

offerChannel

close