Class BackgroundCleaner

java.lang.Object
org.apache.derby.impl.services.cache.BackgroundCleaner
All Implemented Interfaces:
Serviceable

final class BackgroundCleaner extends Object implements Serviceable
A background cleaner that ConcurrentCache can use to clean Cacheables asynchronously in a background instead of synchronously in the user threads. It is normally used by the replacement algorithm in order to make dirty Cacheables clean and evictable in the future. When the background cleaner is asked to clean an item, it puts the item in a queue and requests to be serviced by a DaemonService running in a separate thread.
  • Field Details

    • daemonService

      private final DaemonService daemonService
      The service thread which performs the clean operations.
    • clientNumber

      private final int clientNumber
      Subscription number for this Serviceable.
    • scheduled

      private final AtomicBoolean scheduled
      Flag which tells whether the cleaner has a still unprocessed job scheduled with the daemon service. If this flag is true, calls to serviceNow() won't result in the cleaner being serviced.
    • queue

      private final ArrayBlockingQueue<CacheEntry> queue
      A queue of cache entries that need to be cleaned.
    • shrink

      private volatile boolean shrink
      Flag which tells whether the cleaner should try to shrink the cache the next time it wakes up.
    • cacheManager

      private final ConcurrentCache cacheManager
      The cache manager owning this cleaner.
  • Constructor Details

    • BackgroundCleaner

      BackgroundCleaner(ConcurrentCache cache, DaemonService daemon, int queueSize)
      Create a background cleaner instance and subscribe it to a daemon service.
      Parameters:
      cache - the cache manager that owns the cleaner
      daemon - the daemon service which perfoms the work
      queueSize - the maximum number of entries to keep in the queue (must be greater than 0)
  • Method Details

    • scheduleClean

      boolean scheduleClean(CacheEntry entry)
      Try to schedule a clean operation in the background cleaner.
      Parameters:
      entry - the entry that needs to be cleaned
      Returns:
      true if the entry has been scheduled for clean, false if the background cleaner can't clean the entry (its queue is full)
    • scheduleShrink

      void scheduleShrink()
      Request that the cleaner tries to shrink the cache the next time it wakes up.
    • requestService

      private void requestService()
      Notify the daemon service that the cleaner needs to be serviced.
    • unsubscribe

      void unsubscribe()
      Stop subscribing to the daemon service.
    • performWork

      public int performWork(ContextManager context) throws StandardException
      Clean the first entry in the queue. If there is more work, re-request service from the daemon service.
      Specified by:
      performWork in interface Serviceable
      Parameters:
      context - ignored
      Returns:
      status for the performed work (normally Serviceable.DONE)
      Throws:
      StandardException - if Cacheable.clean() fails
    • serviceASAP

      public boolean serviceASAP()
      Indicate that we want to be serviced ASAP.
      Specified by:
      serviceASAP in interface Serviceable
      Returns:
      true
    • serviceImmediately

      public boolean serviceImmediately()
      Indicate that we don't want the work to happen immediately in the user thread.
      Specified by:
      serviceImmediately in interface Serviceable
      Returns:
      false