net.sf.ehcache.CacheManager and net.sf.ehcache.Cache events and propagates those to
CachePeer peers of the Cache asynchronously.
Updates are guaranteed to be replicated in the order in which they are received.
While much faster in operation than RMISynchronousCacheReplicator, it does suffer from a number
of problems. Elements, which may be being spooled to DiskStore may stay around in memory because references
are being held to them from EventMessages which are queued up. The replication thread runs once
per second, limiting the build up. However a lot of elements can be put into a cache in that time. We do not want
to get an OutOfMemoryError using distribution in circumstances when it would not happen if we were
just using the DiskStore.
Accordingly, the Element values in EventMessages are held by java. in the queue,
so that they can be discarded if required by the GC to avoid an OutOfMemoryError. A log message
will be issued on each flush of the queue if there were any forced discards. One problem with GC collection
of SoftReferences is that the VM (JDK1.5 anyway) will do that rather than grow the heap size to the maximum.
The workaround is to either set minimum heap size to the maximum heap size to force heap allocation at start
up, or put up with a few lost messages while the heap grows.
| Modifier and Type | Class and Description |
|---|---|
| private class | RMIAsynchronousCacheReplicator.ReplicationThread
A background daemon thread that writes objects to the file. |
| Modifier and Type | Field and Description |
|---|---|
| private static final Logger | |
| private final int | maximumBatchSize
The maximum number of Element replication in single RMI message. |
| private final int | replicationInterval
The amount of time the replication thread sleeps after it detects the replicationQueue is empty before checking again. |
| private final Queue | replicationQueue
A queue of updates. |
| private final Thread | replicationThread
A thread which handles replication, so that replication can take place asynchronously and not hold up the cache |
| Access | Constructor and Description |
|---|---|
| public | RMIAsynchronousCacheReplicator(boolean replicatePuts, boolean replicatePutsViaCopy, boolean replicateUpdates, boolean replicateUpdatesViaCopy, boolean replicateRemovals, int replicationInterval, int maximumBatchSize)
Constructor for internal and subclass use |
| Modifier and Type | Method and Description |
|---|---|
| protected void | |
| public Object | Returns: a cloneOverrides net. Implements net. |
| public final void | dispose()
Overrides net. Implements net. |
| private List | Returns: a list of EventMessages which were able to be resolvedExtracts CacheEventMessages and attempts to get a hard reference to the underlying EventMessage If an EventMessage has been invalidated due to SoftReference collection of the Element, it is not propagated. |
| private void | |
| public final void | notifyElementPut(final Ehcache
the cache emitting the notification cache, final Element the element which was just put into the cache. element)Overrides net. Implements net. |
| public final void | notifyElementRemoved(final Ehcache
the cache emitting the notification cache, final Element the element just deleted, or a synthetic element with just the key set if
no element was removed. element)Overrides net. Implements net. |
| public final void | notifyElementUpdated(final Ehcache
the cache emitting the notification cache, final Element the element which was just put into the cache. element)Overrides net. Implements net. |
| public void | notifyRemoveAll(final Ehcache
the cache emitting the notification cache)Overrides net. Implements net. net. to indicate that the all
elements have been removed from the cache in a bulk operation.
|
| private void | |
| private void |
| LOG | back to summary |
|---|---|
| private static final Logger LOG Hides net. | |
| maximumBatchSize | back to summary |
|---|---|
| private final int maximumBatchSize The maximum number of Element replication in single RMI message. | |
| replicationInterval | back to summary |
|---|---|
| private final int replicationInterval The amount of time the replication thread sleeps after it detects the replicationQueue is empty before checking again. | |
| replicationQueue | back to summary |
|---|---|
| private final Queue<Object> replicationQueue A queue of updates. | |
| replicationThread | back to summary |
|---|---|
| private final Thread replicationThread A thread which handles replication, so that replication can take place asynchronously and not hold up the cache | |
| RMIAsynchronousCacheReplicator | back to summary |
|---|---|
| public RMIAsynchronousCacheReplicator(boolean replicatePuts, boolean replicatePutsViaCopy, boolean replicateUpdates, boolean replicateUpdatesViaCopy, boolean replicateRemovals, int replicationInterval, int maximumBatchSize) Constructor for internal and subclass use | |
| addToReplicationQueue | back to summary |
|---|---|
| protected void addToReplicationQueue(RmiEventMessage eventMessage) Adds a message to the queue. This method checks the state of the replication thread and warns if it has stopped and then discards the message. | |
| clone | back to summary |
|---|---|
| public Object clone() throws CloneNotSupportedException Overrides net. Implements net. Creates a clone of this listener. This method will only be called by ehcache before a cache is initialized. This may not be possible for listeners after they have been initialized. Implementations should throw CloneNotSupportedException if they do not support clone.
| |
| dispose | back to summary |
|---|---|
| public final void dispose() Overrides net. Implements net. Give the replicator a chance to flush the replication queue, then cleanup and free resources when no longer needed | |
| extractEventMessages | back to summary |
|---|---|
| private List Extracts CacheEventMessages and attempts to get a hard reference to the underlying EventMessage If an EventMessage has been invalidated due to SoftReference collection of the Element, it is not propagated. This only affects puts and updates via copy.
| |
| flushReplicationQueue | back to summary |
|---|---|
| private void flushReplicationQueue() | |
| notifyElementPut | back to summary |
|---|---|
| public final void notifyElementPut(final Ehcache cache, final Element element) throws CacheException Overrides net. Implements net. Doc from net. Called immediately after an element has been put into the cache. The Implementers may wish to have access to the Element's fields, including value, so the element is provided. Implementers should be careful not to modify the element. The effect of any modifications is undefined. This implementation queues the put notification for in-order replication to peers. | |
| notifyElementRemoved | back to summary |
|---|---|
| public final void notifyElementRemoved(final Ehcache cache, final Element element) throws CacheException Overrides net. Implements net. Called immediately after an attempt to remove an element. The remove method will block until this method returns. This notification is received regardless of whether the cache had an element matching the removal key or not. If an element was removed, the element is passed to this method, otherwise a synthetic element, with only the key set is passed in.
| |
| notifyElementUpdated | back to summary |
|---|---|
| public final void notifyElementUpdated(final Ehcache cache, final Element element) throws CacheException Overrides net. Implements net. Called immediately after an element has been put into the cache and the element already existed in the cache. This is thus an update.
The Implementers may wish to have access to the Element's fields, including value, so the element is provided. Implementers should be careful not to modify the element. The effect of any modifications is undefined. | |
| notifyRemoveAll | back to summary |
|---|---|
| public void notifyRemoveAll(final Ehcache cache) Overrides net. Implements net. Called during This notification exists because clearing a cache is a special case. It is often not practical to serially process notifications where potentially millions of elements have been bulk deleted.
| |
| replicationThreadMain | back to summary |
|---|---|
| private void replicationThreadMain() RemoteDebugger method for the replicationQueue thread. Note that the replicationQueue thread locks the cache for the entire time it is writing elements to the disk. | |
| writeReplicationQueue | back to summary |
|---|---|
| private void writeReplicationQueue() Gets called once per Sends accumulated messages in bulk to each peer. i.e. if ther are 100 messages and 1 peer, 1 RMI invocation results, not 100. Also, if a peer is unavailable this is discovered in only 1 try. Makes a copy of the queue so as not to hold up the enqueue operations. Any exceptions are caught so that the replication thread does not die, and because errors are expected, due to peers becoming unavailable. This method issues warnings for problems that can be fixed with configuration changes. | |
| Access | Constructor and Description |
|---|---|
| public |
| Modifier and Type | Method and Description |
|---|---|
| public final void | run()
Overrides java. Implements java. |
| ReplicationThread | back to summary |
|---|---|
| public ReplicationThread() | |
| run | back to summary |
|---|---|
| public final void run() Overrides java. Implements java. RemoteDebugger thread method. | |