Diseño de un caché de carga de guayaba con vencimiento de entrada variable

Le sugiero que incluya el tiempo de caducidad directamente en su clase de entrada y lo desaloje manualmente de la caché si ha expirado inmediatamente después de obtenerlo de la caché:

MyItem item = cache.getIfPresent(key);
if (item != null && item.isExpired()) {
    cache.invalidate(key);
    item = cache.get(key);
    // or use cache.put if you load it externally
}

Como alternativa, puedo sugerirle que revise la biblioteca EhCache que admite la política de caducidad por elemento.

LoadingCache ofrece algunas políticas de caducidad de uso común, pero cuando estas se quedan cortas para lo que necesita, necesita rodar su propia.

Simplemente agrega un DelayQueue. Cada vez que agregue algo a la caché, agregue un Delayed a esa cola, con el tiempo de caducidad apropiado. El objeto Delayed debe tener un (débil? referencia a la clave.

El ingrediente final es que necesita sondear periódicamente esta cola, para ver si algo expiró y tiene que ser desalojado. No necesariamente añadir un hilo para hacer esto, usted podría simplemente piggyback en cualquier hilo está accediendo a la LoadingCache. Justo antes de acceder a la caché, por ejemplo:

private void drainCache() {
  MyDelayed expired;
  while ((expired = delayedQueue.poll()) != null) {
    K key = expired.getReference();
    if (key != null) { // this only in case if you hold the key in a weak reference
      loadingCache.invalidate(key);
    }
  }
}

..
V lookup(K key) {
  drainCache();
  return loadingCache.getUnchecked(key);
}

Supongo que podría usar el invalidar explícito para definir exactamente qué entradas deben ser desalojadas, pero eso no es probablemente lo que desea.

Sin embargo, puede dar diferentes pesos para las entradas. No es perfecto, pero puede guiar la caché para desalojar las entradas que son menos importantes. Ver Weighter, las entradas con peso 0 no serán desalojadas por desalojo por tamaño.

En caso de que las entradas sean grandes y necesites conservar memoria, no creo que haya una buena solución, pero estos hacks vienen en mente:

• Utilice un PriorityQueue ordenado por el tiempo de caducidad para eliminar manualmente las entradas. Si desea asegurarse de que ninguna entrada caducada se utiliza, necesita combinar esto con la solución de hoaz; la cola solo evita que las entradas inútiles ocupen memoria.

• Usted escribió " algunos valores asociados pueden expirar y others may not", lo que sugiere que el retraso de vencimiento es el mismo para todas las entradas que expiran. Esto permitiría usar un Queue más simple y rápido (por ejemplo, ArrayDeque en lugar del PriorityQueue).

• En caso de que el retraso de vencimiento sea bastante grande, puede dejar que todas las entradas caduquen y volver a insertar aquellas que deberían vivir para siempre en un RemovalListener. Esto puede fallar de dos maneras: 1. Usted puede conseguir una señorita en el ínterin. 2. Las eliminaciones y re-inserciones pueden costar mucho tiempo de CPU.