## com.sun.grizzly.connectioncache.impl.transport
Class InboundConnectionCacheBlockingImpl<C extends Closeable>

    java.lang.Object
      com.sun.grizzly.connectioncache.impl.transport.ConnectionCacheBase<C>
          com.sun.grizzly.connectioncache.impl.transport.InboundConnectionCacheBlockingImpl<C>

All Implemented Interfaces:
  ConnectionCache<C>, InboundConnectionCache<C>

    public final class InboundConnectionCacheBlockingImpl<C extends Closeable>

extends ConnectionCacheBase<C>
implements InboundConnectionCache<C>

Manage connections that are initiated from another VM.

Author:
  Ken Cavanaugh

Field Summary
`protected int` `totalBusy`
`protected int` `totalIdle`

Fields inherited from class com.sun.grizzly.connectioncache.impl.transport.ConnectionCacheBase
`logger, reclaimableConnections`

Constructor Summary
`InboundConnectionCacheBlockingImpl(String cacheType, int highWaterMark, int numberToReclaim, Logger logger)`

Method Summary
`void` `close(C conn)` Close a connection, regardless of whether the connection is busy or not.
`long` `numberOfBusyConnections()` Number of non-idle connections.
`long` `numberOfConnections()` Total number of connections currently managed by the cache.
`long` `numberOfIdleConnections()` Number of idle connections; that is, connections for which the number of get/release or responseReceived/responseProcessed calls are equal.
`long` `numberOfReclaimableConnections()` Number of idle connections that are reclaimable.
`void` `requestProcessed(C conn, int numResponsesExpected)` Indicate that request processing has been completed for a request received on conn.
`void` `requestReceived(C conn)` Mark a connection as busy because a request is being processed on the connection.
`void` `responseSent(C conn)` Decrement the number of expected responses.
`protected String` `thisClassName()`

Methods inherited from class com.sun.grizzly.connectioncache.impl.transport.ConnectionCacheBase
`debug, dprint, dprintStatistics, getCacheType, highWaterMark, numberToReclaim, reclaim, toString`

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

Methods inherited from interface com.sun.grizzly.connectioncache.spi.transport.ConnectionCache
`getCacheType, highWaterMark, numberOfBusyConnections, numberOfConnections, numberOfIdleConnections, numberOfReclaimableConnections, numberToReclaim`

Field Detail

### totalBusy

    protected int totalBusy

### totalIdle

    protected int totalIdle

Constructor Detail

### InboundConnectionCacheBlockingImpl

    public InboundConnectionCacheBlockingImpl(String cacheType,
                                              int highWaterMark,
                                              int numberToReclaim,
                                              Logger logger)

Method Detail

### thisClassName

    protected String thisClassName()

  Specified by:
    `thisClassName` in class `ConnectionCacheBase<C extends Closeable>`

### requestReceived

    public void requestReceived(C conn)

  Description copied from interface: `InboundConnectionCache`
  Mark a connection as busy because a request is being processed on the connection. The connection may or may not be previously known to the cache when this method is called. Busy connections cannot be reclaimed. This provides an early indication that a Connection is in use, before we know how many responses still need to be sent on the Connection for this request. This reduces the likelyhood of reclaiming a connection on which we are processing a request.

  Note that this problem is inherent in a distributed system. We could in any case reclaim a connection AFTER a client has sent a request but BEFORE the request is received. Note that AFTER and BEFORE refer to global time which does not really exist in a distributed system (or at least we want to pretend it is not available). XXX Should we age out connections? This would require actual time stamps, rather than just an LRU queue.

  Specified by:
    `requestReceived` in interface `InboundConnectionCache<C extends Closeable>`
  Parameters:
    `conn` - a connection

### requestProcessed

    public void requestProcessed(C conn,
                                 int numResponsesExpected)

  Description copied from interface: `InboundConnectionCache`
  Indicate that request processing has been completed for a request received on conn. This indicates that a Connection that received a request as indicated in a previous call to requestReceived has completed request processing for that request. Responses may still need to be sent. Some number of responses (usually 0 or 1) may be expected ON THE SAME CONNECTION even for an idle connection. We maintain a count of the number of outstanding responses we expect for protocols that return the response on the same connection on which the request was received. This is necessary to prevent reclamation of a Connection that is idle, but still needed to send responses to old requests.

  Specified by:
    `requestProcessed` in interface `InboundConnectionCache<C extends Closeable>`
  Parameters:
    `conn` - a connection
    `numResponsesExpected` - number of connections in which a response is expected

### responseSent

    public void responseSent(C conn)

  Decrement the number of expected responses. When a connection is idle and has no expected responses, it can be reclaimed.

  Specified by:
    `responseSent` in interface `InboundConnectionCache<C extends Closeable>`
  Parameters:
    `conn` - a connection

### close

    public void close(C conn)

  Close a connection, regardless of whether the connection is busy or not.

  Specified by:
    `close` in interface `ConnectionCache<C extends Closeable>`
  Parameters:
    `conn` - a connection

### numberOfConnections

    public long numberOfConnections()

  Description copied from interface: `ConnectionCache`
  Total number of connections currently managed by the cache.

  Returns:
    number of connections currently managed by the cache

### numberOfIdleConnections

    public long numberOfIdleConnections()

  Description copied from interface: `ConnectionCache`
  Number of idle connections; that is, connections for which the number of get/release or responseReceived/responseProcessed calls are equal.

  Returns:
    number of idle connections

### numberOfBusyConnections

    public long numberOfBusyConnections()

  Description copied from interface: `ConnectionCache`
  Number of non-idle connections. Normally, busy+idle==total, but this may not be strictly true due to concurrent updates to the connection cache.

  Returns:
    number of busy connections

### numberOfReclaimableConnections

    public long numberOfReclaimableConnections()

  Description copied from interface: `ConnectionCache`
  Number of idle connections that are reclaimable. Such connections are not in use, and are not waiting to handle any responses.

  Returns:
    number of idle connections that are reclaimable

Copyright © 2008 SUN Microsystems. All Rights Reserved.