надежное принуждение к выселению карты Гуавы

Я не большой поклонник взлома или разветвления внешнего кода до тех пор, пока это не станет абсолютно необходимым. Эта проблема возникает отчасти из-за раннего решения MapMaker разветвить ConcurrentHashMap, тем самым усложнив задачу, которую можно было бы отложить до тех пор, пока не будут разработаны алгоритмы. При установке исправлений над MapMaker код становится устойчивым к изменениям в библиотеке, поэтому вы можете удалить свой обходной путь по собственному расписанию.

Простой подход — использовать приоритетную очередь слабых эталонных задач и выделенный поток. Недостатком этого является создание множества устаревших неоперабельных задач, которые могут стать чрезмерными из-за штрафа за вставку O(lg n). Он работает достаточно хорошо для небольших, редко используемых кэшей. Это был оригинальный подход, принятый MapMaker, и было просто написать собственный декоратор.

Более надежным выбором является отражение модели амортизации блокировок с одной очередью истечения срока действия. Голова очереди может быть изменчивой, чтобы операция чтения всегда могла проверить, не истек ли срок ее действия. Это позволяет всем операциям чтения инициировать истечение срока действия, а необязательный поток очистки будет регулярно проверять.

Безусловно, самым простым является использование #concurrencyLevel(1), чтобы заставить MapMaker использовать один сегмент. Это уменьшает параллелизм записи, но большинство кешей интенсивно читаются, поэтому потери минимальны. Оригинальный хак, чтобы подтолкнуть карту с помощью фиктивного ключа, тогда будет работать нормально. Это был бы мой предпочтительный подход, но два других варианта подходят, если у вас высокая нагрузка на запись.

Я не знаю, подходит ли это для вашего варианта использования, но ваше основное беспокойство по поводу отсутствия вытеснения фонового кеша, похоже, связано с потреблением памяти, поэтому я бы подумал, что использование softValues() в MapMaker, чтобы позволить сборщику мусора восстанавливать записи из кеша, когда возникает ситуация с нехваткой памяти. Легко может быть решением для вас. Я использовал это на сервере подписки (ATOM), где записи обслуживаются через кеш Guava с использованием SoftReferences для значений.

Основываясь на ответе maaartinus, я придумал следующий код, который использует отражение, а не напрямую модифицирует источник (если вы найдете это полезным, проголосуйте за его ответ!). Хотя это приведет к снижению производительности за использование отражения, разница должна быть незначительной, поскольку я буду запускать его примерно раз в 20 минут для каждой кэширующей карты (я также кэширую динамические поиски в статическом блоке, что поможет). Я провел некоторое первоначальное тестирование, и, похоже, оно работает так, как задумано:

public class GuavaEvictionHacker {

   //Class objects necessary for reflection on Guava classes - see Guava docs for info
   private static final Class<?> computingMapAdapterClass;
   private static final Class<?> nullConcurrentMapClass;
   private static final Class<?> nullComputingConcurrentMapClass;
   private static final Class<?> customConcurrentHashMapClass;
   private static final Class<?> computingConcurrentHashMapClass;
   private static final Class<?> segmentClass;

   //MapMaker$ComputingMapAdapter#cache points to the wrapped CustomConcurrentHashMap
   private static final Field cacheField;

   //CustomConcurrentHashMap#segments points to the array of Segments (map partitions)
   private static final Field segmentsField;

   //CustomConcurrentHashMap$Segment#runCleanup() enforces eviction on the calling Segment
   private static final Method runCleanupMethod;

   static {
      try {

         //look up Classes
         computingMapAdapterClass = Class.forName("com.google.common.collect.MapMaker$ComputingMapAdapter");
         nullConcurrentMapClass = Class.forName("com.google.common.collect.MapMaker$NullConcurrentMap");
         nullComputingConcurrentMapClass = Class.forName("com.google.common.collect.MapMaker$NullComputingConcurrentMap");
         customConcurrentHashMapClass = Class.forName("com.google.common.collect.CustomConcurrentHashMap");
         computingConcurrentHashMapClass = Class.forName("com.google.common.collect.ComputingConcurrentHashMap");
         segmentClass = Class.forName("com.google.common.collect.CustomConcurrentHashMap$Segment");

         //look up Fields and set accessible
         cacheField = computingMapAdapterClass.getDeclaredField("cache");
         segmentsField = customConcurrentHashMapClass.getDeclaredField("segments");
         cacheField.setAccessible(true);
         segmentsField.setAccessible(true);

         //look up the cleanup Method and set accessible
         runCleanupMethod = segmentClass.getDeclaredMethod("runCleanup");
         runCleanupMethod.setAccessible(true);
      }
      catch (ClassNotFoundException cnfe) {
         throw new RuntimeException("ClassNotFoundException thrown in GuavaEvictionHacker static initialization block.", cnfe);
      }
      catch (NoSuchFieldException nsfe) {
         throw new RuntimeException("NoSuchFieldException thrown in GuavaEvictionHacker static initialization block.", nsfe);
      }
      catch (NoSuchMethodException nsme) {
         throw new RuntimeException("NoSuchMethodException thrown in GuavaEvictionHacker static initialization block.", nsme);
      }
   }

   /**
    * Forces eviction to take place on the provided Guava Map. The Map must be an instance
    * of either {@code CustomConcurrentHashMap} or {@code MapMaker$ComputingMapAdapter}.
    * 
    * @param guavaMap the Guava Map to force eviction on.
    */
   public static void forceEvictionOnGuavaMap(ConcurrentMap<?, ?> guavaMap) {

      try {

         //we need to get the CustomConcurrentHashMap instance
         Object customConcurrentHashMap;

         //get the type of what was passed in
         Class<?> guavaMapClass = guavaMap.getClass();

         //if it's a CustomConcurrentHashMap we have what we need
         if (guavaMapClass == customConcurrentHashMapClass) {
            customConcurrentHashMap = guavaMap;
         }
         //if it's a NullConcurrentMap (auto-evictor), return early
         else if (guavaMapClass == nullConcurrentMapClass) {
            return;
         }
         //if it's a computing map we need to pull the instance from the adapter's "cache" field
         else if (guavaMapClass == computingMapAdapterClass) {
            customConcurrentHashMap = cacheField.get(guavaMap);
            //get the type of what we pulled out
            Class<?> innerCacheClass = customConcurrentHashMap.getClass();
            //if it's a NullComputingConcurrentMap (auto-evictor), return early
            if (innerCacheClass == nullComputingConcurrentMapClass) {
               return;
            }
            //otherwise make sure it's a ComputingConcurrentHashMap - error if it isn't
            else if (innerCacheClass != computingConcurrentHashMapClass) {
               throw new IllegalArgumentException("Provided ComputingMapAdapter's inner cache was an unexpected type: " + innerCacheClass);
            }
         }
         //error for anything else passed in
         else {
            throw new IllegalArgumentException("Provided ConcurrentMap was not an expected Guava Map: " + guavaMapClass);
         }

         //pull the array of Segments out of the CustomConcurrentHashMap instance
         Object[] segments = (Object[])segmentsField.get(customConcurrentHashMap);

         //loop over them and invoke the cleanup method on each one
         for (Object segment : segments) {
            runCleanupMethod.invoke(segment);
         }
      }
      catch (IllegalAccessException iae) {
         throw new RuntimeException(iae);
      }
      catch (InvocationTargetException ite) {
         throw new RuntimeException(ite.getCause());
      }
   }
}

Я ищу отзывы о том, рекомендуется ли этот подход в качестве временной меры, пока проблема не будет решена в выпуске Guava, особенно от членов команды Guava, когда у них появится минутка.

РЕДАКТИРОВАНИЕ: обновлено решение, позволяющее автоматически удалять карты (NullConcurrentMap или NullComputingConcurrentMap, находящиеся в ComputingMapAdapter). В моем случае это оказалось необходимым, так как я вызываю этот метод на всех своих картах, а некоторые из них являются автовыталкивателями.