docs: public void run()
      {
          synchronized (ivCancelLock) { //d601399
              if (ivIsCanceled) { //d583637         
                  //if this instance has been canceled, we do no more processing.
                  // this also guarantees that a future alarm is not created.
                  return;
              }
  
              long newSweepInterval = ivNewSweepInterval;
              // NOTE: clamp happens before initializeSweepInterval call to avoid spurious
              // re-init for too-low minimum
              if (ivSweepInterval != newSweepInterval)
              {
                  initializeSweepInterval(newSweepInterval);
              }
  
              int newPreferredCacheSize = ivNewPreferredMaxSize;
              if (ivPreferredMaxSize != newPreferredCacheSize)
              {
                  initializeCacheData(newPreferredCacheSize);
              }
  
              try
              {
                  // For dynamic tuning purposes, make the eviction strategy less
                  // aggressive (i.e. allow objects to age in the cache longer)
                  // if the last several sweeps have resulted in the cache being
                  // reduced below the soft limit.                               d118138
                  if (ivNumBelowSoftLimit > ivMaxDiscardThreshold)
                  {
                      // First, increase the discard threshold, and if the cache
                      // size remains low, then increase the sweep interval.       d231690
                      if (ivDiscardThreshold < ivMaxDiscardThreshold)
                      {
                          ++ivDiscardThreshold;
                      }
                      else if (ivSweepInterval < ivMaxSweepInterval)
                      {
                          ivSweepInterval = ivSweepInterval + SWEEP_INTERVAL_ADJUST;
                      }
                      ivNumBelowSoftLimit = 0;
                  }
  
                  // For LRU purposes, keep a count of the number of times this
                  // alarm is fired. The cache inserts this data in each
                  // element when it is last accessed, so it can be determined
                  // how old it is in the cache.
                  if (ivCache.numSweeps == Long.MAX_VALUE)
                      ivCache.numSweeps = 1;
                  else
                      ivCache.numSweeps++;
  
                  // If the soft limit has been reached, then sweep through
                  // the cache elements looking for some to evict. Otherwise,
                  // just increment the sweep count (above) for LRU purposes.
                  if (preferredSizeReached())
                  {
                      sweep();
  
                      // For dynamic tuning purposes, make the eviction strategy more
                      // aggressive (i.e. allow objects to be evicted from the cache
                      // earlier) if the above sweep did not succeed in reducing
                      // the cache below the internal 'upper' limit.               d118138
                      if (preferredSizeReached())
                      {
                          ivNumBelowSoftLimit = 0;
  
                          if (ivCache.numObjects > ivUpperLimit)
                          {
                              // First, try sweeping more frequently, and then if
                              // that doesn't work, reduce the discard threshold.    d231690
                              if (ivSweepInterval > MINIMUM_ADJUSTED_INTERVAL)
                              {
                                  ivSweepInterval = ivSweepInterval - SWEEP_INTERVAL_ADJUST;
                              }
                              else if (ivDiscardThreshold > ivMinDiscardThreshold)
                              {
                                  --ivDiscardThreshold;
                                  sweep();
                              }
                          }
                      }
                      else
                      {
                          ++ivNumBelowSoftLimit;
                      }
                  }
                  else
                  {
                      if (TraceComponent.isAnyTracingEnabled() && isTraceEnabled(true))
                          Tr.debug(tc.isDebugEnabled() ? tc : tcOOM,
                                   ivCache.getName() + ": Sweep (" + ivCache.numSweeps +
                                                   "," + ivDiscardThreshold + "," + ivSweepInterval + ")" +
                                                   " - Cache limit not reached : " + ivCache.getSize() +
                                                   "/" + ivPreferredMaxSize);
  
                      ++ivNumBelowSoftLimit;
                  }
              } catch (Throwable e) //PM11713
              {
                  FFDCFilter.processException(e, CLASS_NAME + ".alarm", "424", this);
                  Tr.warning(tc, "LRU_THREAD_CAUGHT_EXCEPTION_CNTR0053W",
                             new Object[] { this, e }); //p111002.4
              } finally
              {
                  // Unless the preferred size has been reached, use the deferrable 
                  // scheduler.  They will be the same for traditional WAS, but in Liberty we 
                  // use the deferrable until we need the non-deferrable one to keep
                  // up with cache usage.
                  ScheduledExecutorService executor = preferredSizeReached() ?
                                  ivScheduledExecutorService :
                                  ivDeferrableScheduledExecutorService;
                  ivScheduledFuture = executor.schedule(this, ivSweepInterval, TimeUnit.MILLISECONDS); // F73234
              }
          }
      }