Implementazione di una cache periodicamente aggiornata in Java

Question

Il mio caso d'uso è di mantenere una cache in memoria sui dati memorizzati in un DB persistente.

Uso i dati per compilare una lista/mappa di voci sull'interfaccia utente. In qualsiasi momento, i dati visualizzati sull'interfaccia utente dovrebbero essere il più aggiornati possibile (beh, questo può essere fatto dalla frequenza di aggiornamento della cache).

La differenza principale tra un'implementazione regolare della cache e questa particolare cache è che ha bisogno di un aggiornamento di massa di tutti gli elementi a intervalli regolari e quindi è piuttosto diverso da un tipo di cache LRU.

Ho bisogno di fare questa implementazione in Java e sarà fantastico se ci sono dei framework esistenti che possono essere utilizzati per ottenere questo costruito attorno ad essi.

Ho esplorato la libreria cache di Google Guava ma è più adatto a un aggiornamento per voce piuttosto che a un aggiornamento in blocco. Non ci sono semplici API che eseguono un aggiornamento sull'intera cache.

Qualsiasi aiuto sarà molto apprezzato.

Inoltre, se è possibile eseguire l'aggiornamento in modo incrementale, sarà grande perché l'unica limitazione che si verifica durante l'aggiornamento dell'intera cache è che se la cache è di dimensioni molto grandi, l'heap della memoria deve essere almeno due volte la dimensione della cache per caricare le nuove voci e sostituire la vecchia mappa con quella nuova. Se la cache è incrementale o c'è un aggiornamento a blocchi (aggiornamento in dimensioni uguali) sarà fantastico.

Answer 1

EHCache è una libreria bella full-optional Java caching. immagino che abbiano qualcosa che possa funzionare per te.

Per eseguire un ricaricamento incrementale di una cache (che funzionerebbe sulla maggior parte delle cache), è sufficiente scorrere le voci attualmente caricate e forzarle ad aggiornarle. (è possibile eseguire questa attività su un programma di pianificazione in background).

In alternativa a forzare l'intera cache a ricaricare, EHCache ha la possibilità di specificare un "time-to-live" per una voce, in modo che le voci vengano ricaricate automaticamente se sono obsolete.

Answer 2

Proprio ereditano questa classe, e attuare loadDataFromDB e UpdateData come si desidera ottenere gli aggiornamenti incremential

import org.apache.log4j.Logger; 
import java.util.List; 
import java.util.concurrent.Semaphore; 


public abstract class Updatable<T> 
{ 
    protected volatile long lastRefreshed = 0; 
    private final int REFRESH_FREQUENCY_MILLISECONDS = 300000; // 5 minutes 
    private Thread updateThread; 
    private final Semaphore updateInProgress = new Semaphore(1); 

    protected static final Logger log = Logger.getLogger(Updatable.class); 

    public void forceRefresh() 
    { 
     try 
     { 
      updateInProgress.acquire(); 
     } 
     catch (InterruptedException e) 
     { 
      log.warn("forceRefresh Interrupted"); 
     } 

     try 
     { 
      loadAllData(); 
     } 
     catch (Exception e) 
     { 
      log.error("Exception while updating data from DB", e); 
     } 
     finally 
      { 
      updateInProgress.release(); 
     } 

    } 

    protected void checkRefresh() 
    { 
     if (lastRefreshed + REFRESH_FREQUENCY_MILLISECONDS <  System.currentTimeMillis()) 
      startUpdateThread(); 
    } 

    private void startUpdateThread() 
    { 
     if (updateInProgress.tryAcquire()) 
     { 
      updateThread = new Thread(new Runnable() 
      { 
       public void run() 
       { 
        try 
        { 
         loadAllData(); 
        } 
        catch (Exception e) 
        { 
         log.error("Exception while updating data from DB", e); 
        } 
        finally 
        { 
         updateInProgress.release(); 
        } 
       } 
      }); 

      updateThread.start(); 
     } 
    } 

    /** 
    * implement this function to load the data from DB 
    * 
    * @return 
    */ 
    protected abstract List<T> loadFromDB(); 

    /** 
    * Implement this function to hotswap the data in memory after it was loaded from DB 
    * 
    * @param data 
    */ 
    protected abstract void updateData(List<T> data); 

    private void loadAllData() 
    { 
     List<T> l = loadFromDB(); 
     updateData(l); 
     lastRefreshed = System.currentTimeMillis(); 
    } 

    public void invalidateCache() 
    { 
     lastRefreshed = 0; 
    } 

} 

Answer 3

Una cosa che deve essere controllata è che è necessario un aggiornamento periodico? È possibile applicare la logica di aggiornamento una volta recuperati i dati dalla cache, questo eliminerebbe la necessità di qualsiasi aggiornamento asincrono e rimuoverebbe la necessità di mantenere le vecchie copie della cache. Questo IMO è il modo più semplice e migliore per aggiornare i dati della cache in quanto non comporta alcun overhead aggiuntivo.

T getData(){ 
     // check if the last access time + refresh interval >= currenttime if so then refresh cache 
    // return data 
    } 

Questo farà sì che i dati vengono aggiornati sulla base all'intervallo di aggiornamento e non ha bisogno di alcun aggiornamento asincrono.