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

java.lang.Object
  extended by com.sun.grizzly.connectioncache.impl.transport.ConnectionCacheBase<C>
      extended by 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 © 2011 SUN Microsystems. All Rights Reserved.