Come impedire il caricamento simultaneo di valori non memorizzati più volte?

Question

Come evitare di caricare il valore che non è presente nella cache molte volte simultaneamente, nel modo efficiente?

Un tipico utilizzo della cache è pseudocodice seguente:

Object get(Object key) { 
Object value = cache.get(key); 
if (value == null) { 
    value = loadFromService(key); 
    cache.set(key,value); 
} 
return value; 
} 

Il problema: prima che il valore viene caricato dal servizio (Database, WebService, RemoteEJB o altro) una seconda chiamata può essere effettuata nello stesso tempo , che renderà il valore caricato ancora una volta. Ad esempio, quando memorizzo nella cache tutti gli elementi per l'utente X, e questo utente viene spesso visualizzato e contiene molti elementi, c'è un'alta probabilità di chiamare simultaneamente il carico di tutti gli elementi, con conseguente carico gravoso sul server .

Potrei effettuare la funzione getsincronizzata, ma questo forzerebbe altre ricerche ad attendere, non ha molto senso. Potrei creare nuovo blocco per ogni chiave, ma non so se è una buona idea gestire un numero così grande di blocchi in Java (questa parte è specifica della lingua, la ragione per cui l'ho etichettata come java) .

Oppure c'è un altro approccio che potrei usare? Se sì, quale sarebbe il più efficiente?

Answer 1

Non reinventare la ruota, l'utilizzo LoadingCache o memoizing supplier guava.

Se si utilizza Ehcache, leggi circa read-through, questo è lo schema che si richiede. È necessario implementare l'interfaccia CacheEntryFactory per istruire la cache su come leggere gli oggetti in una cache mancante e si deve avvolgere l'istanza Ehcache con un'istanza di SelfPopulatingCache.

Answer 2

Qualcosa che puoi fare in modo generico è utilizzare il codice hash dell'oggetto.

È possibile disporre di una serie di blocchi utilizzati in base al codice hash per ridurre la possibilità di collisioni. O come hack puoi usare il fatto che i byte auto-box restituiscono sempre gli stessi oggetti.

Object get(Object key) { 
    Object value = cache.get(key); 
    if (value == null) { 
     // every possible Byte is cached by the JLS. 
     Byte b = Byte.valueOf((byte) key.hashCode()); 
     synchronized (b) { 
      value = cache.get(key); 
      if (value == null) { 
       value = loadFromService(key); 
       cache.set(key, value); 
      } 
     } 
    } 
    return value; 
} 

Answer 3

Per il tempo di caricamento, inserire un oggetto intermedio nella mappa anziché il risultato per indicare che il caricamento è iniziato ma non è terminato. Sotto java.util.concurrent.FutureTask viene utilizzato per l'oggetto intermedio:

Object get(final Object key) throws Exception { 
    boolean doRun = false; 
    Object value; 
    synchronized (cache) { 
     value = cache.get(key); 
     if (value == null) { 
      value = new FutureTask(new Callable() { 
       @Override 
       public Object call() throws Exception { 
        Object loadedValue = loadFromService(key); 
        synchronized (cache) {cache.put(key, loadedValue);}; 
        return loadedValue; 
       } 

      }); 
      cache.put(key, value); 
      doRun=true; 
     } 
    } 
    if (value instanceof FutureTask) { 
     FutureTask task = (FutureTask) value; 
     if (doRun) { 
      task.run(); 
     } 
     return task.get(); 
    } 
    return value; 
}`