Package org.infinispan.expiration.impl

Class ExpirationManagerImpl<K,V>

java.lang.Object
org.infinispan.expiration.impl.ExpirationManagerImpl<K,V>
All Implemented Interfaces:
ExpirationManager<K,V>, InternalExpirationManager<K,V>
Direct Known Subclasses:
ClusterExpirationManager
@ThreadSafe public class ExpirationManagerImpl<K,V> extends Object implements InternalExpirationManager<K,V>

  • Field Details

    • executor

      protected ScheduledExecutorService executor

    • configuration

      protected Configuration configuration

    • persistenceManager

      protected org.infinispan.persistence.manager.PersistenceManager persistenceManager

    • dataContainer

      protected ComponentRef<InternalDataContainer<K,V>> dataContainer

    • cacheNotifier

      protected CacheNotifier<K,V> cacheNotifier

    • timeService

      protected TimeService timeService

    • keyPartitioner

      protected KeyPartitioner keyPartitioner

    • cacheRef

      protected ComponentRef<AdvancedCache<K,V>> cacheRef

    • enabled

      protected boolean enabled

    • cacheName

      protected String cacheName

    • cache

      protected AdvancedCache<K,V> cache

    • expiring

      protected ConcurrentMap<K,CompletableFuture<Boolean>> expiring
      This map is used for performance reasons. Essentially when an expiration event should not be raised this map should be populated first. The main examples are if an expiration is about to occur for that key or the key will be removed or updated. In the latter case we don't want to send an expiration event and then a remove event when we could do just the removal.

    • expirationTask

      protected ScheduledFuture<?> expirationTask

  • Constructor Details

    • ExpirationManagerImpl

      public ExpirationManagerImpl()

  • Method Details

    • start

      public void start()

    • processExpiration

      public void processExpiration()
      Description copied from interface: ExpirationManager
      Processes the expiration event queue.
      Specified by:
      processExpiration in interface ExpirationManager<K,V>

    • isEnabled

      public boolean isEnabled()
      Specified by:
      isEnabled in interface ExpirationManager<K,V>
      Returns:
      true if expiration reaper thread is enabled, false otherwise

    • entryExpiredInMemory

      public CompletableFuture<Boolean> entryExpiredInMemory(InternalCacheEntry<K,V> entry, long currentTime, boolean hasLock)
      Description copied from interface: InternalExpirationManager
      This should be invoked passing in an entry that is now expired. This method may attempt to lock this key to preserve atomicity. This method should be invoked when an entry was read via get but found to be expired.

      This method returns true if the entry was removed due to expiration or false if the entry was not removed due to expiration

      If hasLock is true, this method assumes that the caller has the lock for the key and it must allow the expiration to occur, ie. returned CompletableFuture has completed, before the lock is released. Failure to do so may cause inconsistency in data.

      Specified by:
      entryExpiredInMemory in interface InternalExpirationManager<K,V>
      Parameters:
      entry - the entry that has expired
      currentTime - the current time when it expired
      hasLock - if the expiration was found during a write operation
      Returns:
      if this entry actually expired or not

    • handleInStoreExpirationInternal

      public CompletionStage<Void> handleInStoreExpirationInternal(K key)
      Description copied from interface: InternalExpirationManager
      This is to be invoked when a store entry expires. This method may attempt to lock this key to preserve atomicity.

      Note this method doesn't currently take a InternalCacheEntry and this is due to a limitation in the cache store API. This may cause some values to be removed if they were updated at the same time.

      Specified by:
      handleInStoreExpirationInternal in interface InternalExpirationManager<K,V>
      Parameters:
      key - the key of the expired entry This method will be renamed to handleInStoreExpiration when the method can be removed from ExpirationManager

    • handleInStoreExpirationInternal

      public CompletionStage<Void> handleInStoreExpirationInternal(MarshallableEntry<K,V> marshalledEntry)
      Description copied from interface: InternalExpirationManager
      This is to be invoked when a store entry expires and the value and/or metadata is available to be used.
      Specified by:
      handleInStoreExpirationInternal in interface InternalExpirationManager<K,V>
      Parameters:
      marshalledEntry - the entry that can be unmarshalled as needed This method will be renamed to handleInStoreExpiration when the method can be removed from ExpirationManager

    • handlePossibleExpiration

      public CompletionStage<Boolean> handlePossibleExpiration(InternalCacheEntry<K,V> ice, int segment, boolean isWrite)
      Description copied from interface: InternalExpirationManager
      Handles processing for an entry that may be expired. This will remove the entry if it is expired, otherwise may touch if it uses max idle.
      Specified by:
      handlePossibleExpiration in interface InternalExpirationManager<K,V>
      Parameters:
      ice - entry that may be expired
      segment - the segment of the entry
      isWrite - whether the command that saw the expired value was a write or not
      Returns:
      a stage that will complete with true if the entry was expired and false otherwise

    • checkExpiredMaxIdle

      protected CompletionStage<Boolean> checkExpiredMaxIdle(InternalCacheEntry<?,?> entry, int segment, long currentTime)
      Response is whether the value should be treated as expired. This is determined by if a value as able to be touched or not, that is if it couldn't be touched - we assumed expired (as it was removed in some way).
      Parameters:
      entry - the entry to check expiration and touch
      segment - the segment the entry maps to
      currentTime - the current time in milliseconds
      Returns:
      whether the entry was expired or not

    • stop

      public void stop()

    • addInternalListener

      public void addInternalListener(InternalExpirationManager.ExpirationConsumer<K,V> consumer)
      Description copied from interface: InternalExpirationManager
      Adds an InternalExpirationManager.ExpirationConsumer to be invoked when an entry is expired.

      It exposes the PrivateMetadata

      Specified by:
      addInternalListener in interface InternalExpirationManager<K,V>
      Parameters:
      consumer - The instance to invoke.

    • removeInternalListener

      public void removeInternalListener(Object listener)
      Description copied from interface: InternalExpirationManager
      Removes a previous registered InternalExpirationManager.ExpirationConsumer.
      Specified by:
      removeInternalListener in interface InternalExpirationManager<K,V>
      Parameters:
      listener - The instance to remove.