Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Caché LRU por orden de acceso

Usa un `LinkedHashMap` en orden de acceso para expulsar, al superar el límite de tamaño, la entrada a la que se accedió hace más tiempo, no la primera que se insertó.

Versión: Java SE 21

Sintaxis

new LinkedHashMap<K, V>(initialCapacity, loadFactor, true) { @Override protected boolean removeEldestEntry(Map.Entry<K, V> eldest) { return size() > maxEntries; } }

LRU (least recently used) expulsa la entrada cuyo último acceso es el más antiguo. FIFO (first in, first out) expulsa la primera entrada insertada: leerla no cambia el orden de expulsión. Por tanto, LRU se basa en el último acceso y FIFO en la inserción.

En LinkedHashMap, el tercer argumento del constructor, true, activa el orden de acceso en lugar del orden de inserción predeterminado. Con las operaciones del ejemplo, el recorrido va del acceso menos reciente al más reciente. En Java SE 21, putFirst y putLast colocan explícitamente una entrada al principio o al final sin registrar un acceso, por lo que el orden de recorrido puede diferir del orden de los últimos accesos. Un get sobre una clave presente o un put que actualiza una entrada existente mueve esa entrada al final, si no está ya allí. Un get sobre una clave ausente y containsKey no cambian el orden.

El orden de acceso no limita por sí solo el tamaño del mapa. Tras insertar una entrada nueva con put, el método sobrescrito removeEldestEntry devuelve true si size() > maxEntries, y el mapa elimina su primera entrada. initialCapacity es la capacidad inicial, no un límite de entradas; esta regla no las hace caducar con el tiempo.

LinkedHashMap no está sincronizado. Si varios hilos comparten esta caché, sincroniza el acceso externamente, incluidas las lecturas: get puede cambiar el orden de recorrido.

Ejemplos

import java.util.LinkedHashMap;
import java.util.Map;

public class LruDemo {
    public static void main(String[] args) {
        int maxEntries = 2;
        Map<String, Integer> cache = new LinkedHashMap<>(16, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<String, Integer> eldest) {
                return size() > maxEntries;
            }
        };

        cache.put("A", 1);
        cache.put("B", 2);
        cache.get("A");
        System.out.println(cache.keySet());

        cache.put("C", 3);
        System.out.println(cache.keySet());
    }
}

Resultado

[B, A]
[A, C]

El límite es de dos entradas. `get("A")` mueve `A` detrás de `B`, así que al insertar `C` se expulsa `B`. FIFO expulsaría `A`.

Lecciones relacionadas

  • Java · Lección 40 · Intermedio · Versión: 2

Fuentes