Mise en œuvre d'une périodiquement rafraîchissante Cache en Java

Mon cas d'utilisation est de maintenir un cache en mémoire aux données stockées dans une persistance de la DB.

- Je utiliser les données pour remplir une liste/carte d'entrées de l'INTERFACE utilisateur. À un moment donné, les données affichées sur l'INTERFACE utilisateur doit être mis à jour comme il est possible (bien cela peut être fait par la fréquence de rafraîchissement du cache).

Différence majeure entre un cache normal de mise en œuvre, et ce cache est qu'il a besoin d'un bloc d'actualisation de tous les éléments à intervalles réguliers, et il est donc assez différent d'un type de cache LRU.

J'ai besoin de faire cette mise en œuvre en Java, et il sera grand si il existe des cadres qui peuvent être utilisés pour obtenir ce construit autour d'eux.

J'ai exploré le Google Goyave cache de la bibliothèque, mais il est plus adapté à un par entrée d'actualisation plutôt que d'un bloc d'actualisation. Il n'y a aucune Api simple qui ne une actualisation des données sur l'ensemble de la cache.

Toute aide sera très appréciée.

Aussi, si il est possible de progressivement faire l'actualisation, c'est bien parce que la seule limitation qui survient alors que l'actualisation de l'ensemble de la cache, c'est que si le cache est très grand en taille, puis la mémoire du tas doit être au moins deux fois la taille de la mémoire cache afin de charger les nouvelles entrées et de remplacer l'ancienne carte avec le nouveau. Si le cache est incrémentale ou il y a un bloc refresh (actualiser dans l'égalité des tailles) ça va être super.

OriginalL'auteur Abhishek Jain | 2012-10-05

  1. 3

    EHCache est assez complet de la mise en cache java bibliothèque. j'imagine qu'ils ont quelque chose qui pourrait fonctionner pour vous.

    Afin de faire un différentiel de recharger le cache (qui fonctionne sur la plupart des tous les cache), il suffit de parcourir le chargé des entrées et la force de les actualiser. (vous pouvez exécuter cette tâche sur un fond scheduler).

    Comme une alternative à forcer le cache entier pour recharger, EHCache a la possibilité de spécifier un "time-to-live" pour une entrée, de sorte que les entrées seront automatiquement rechargé si ils sont trop rassis.

    Le BulkLoader API (ehcache.org/documentation/apis/bulk-loading) de EhCache est utile, mais il aurait été très bien si elle avait fourni un refreshTime ou périodique de l'intervalle de temps de l'option où il serait lui-même gérer la planification de l'actualisation du cache. De toute façon, il peut toujours être atteint par le biais d'un planificateur externe, et en invoquant le chargement en vrac API périodiquement. Merci pour la réponse.
    Pour EHCache avoir un regard sur: ehcache.org/documentation/3.3/thread-pools.html et terracotta.org/documentation/4.1/bigmemorymax/api/bulk-loading
    Mais..n'est-ce pas le temps de vivre tout simplement supprime l'élément dans le cache? Ce n'est PAS la même chose que ce que vous avez écrit ici - automatique "rechargement"
    ma suggestion vous obtiendrez d'actualisation incrémentielle. il ne sera pas, comme vous l'avez souligné, d'obtenir les différentiels de précontrainte. si vous avez juste besoin rafraîchissante, alors vous êtes très bien. si vous avez besoin de précontrainte de la fonctionnalité, alors, oui, vous aurez besoin de faire quelque chose de plus.

    OriginalL'auteur jtahlborn

  2. 0

    Juste d'hériter de cette classe, et de mettre en œuvre loadDataFromDB et updateData que vous voulez obtenir le incremential mises à jour

    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;
}
}
    Merci pour la réponse, RA. Quel est le checkRefresh() la fonction va être appelé? Si je comprends bien, ce besoin continu d'un processus en cours d'exécution d'un sondage à l'aide de checkRefresh à intervalles réguliers. Je l'attendais avec impatience un nettoyeur de mise en œuvre où je pourrais juste un nouveau plugin de cache avec un cache du chargeur.
    CheckRefresh doit être appelée pour chaque opération get que vous mettre en œuvre dans votre classe. I. E : Données publiques get() { checkRefresh(); // return data; }
    Mais qui va influer sur le temps de latence de la récupération de données dans les cas où la mise à jour du thread est déclenché lorsque, comme si il était allé de l'avant comme un cron et déjà prefetched les données, un tel cas n'aurait pas surgi.
    Dans notre cas, nous avons décidé que les données peuvent être un peu rassis. Vous pouvez vous assurer que les données n'est jamais obsolètes, si vous extraire de la DB en mode synchrone, mais de cette façon, toutes les demandes devront attendre jusqu'à ce que les données ont été récupérées. Cela est inacceptable pour nous, puisque notre système est très faible latence, et on ne peut s'arrêter à toutes les demandes jusqu'à ce que l'extraction des données.
    Je suis d'accord que nous nous sommes entendus sur les données obsolètes. Le point que j'essayais de faire peut être comprise à partir de l'exemple suivant: le Dire, le cache est actualisé une fois supérieure à la fréquence de rafraîchissement et maintenant, dans la prochaine récupération de la mise à jour du thread aurait besoin de courir et de cette demande de données devrez attendre jusqu'à ce que de nouvelles données sont lues à partir de la DB. Nous aurions pu éviter ce genre de situation si nous avions actualisé à intervalles fixes, indépendamment du fait que si des données sont demandées ou pas. Dans un tel scénario, nous aurons toujours des données à jour chaque fois qu'une demande/obtenir de l'appel est effectué.

    OriginalL'auteur RA.

  3. 0

    Une chose qui doit être vérifié qu'est périodique rafraîchissante nécessaire? Vous pourriez appliquer votre actualisation logique une fois que vous l'extraction de données à partir de la mémoire cache, ce serait de supprimer le besoin de tout asynchrone rafraîchissant et permettrait d'éliminer la nécessité de maintenir toutes les copies anciennes de la cache. Cette OMI est la plus simple et la meilleure façon de rafraîchir le cache de données car il ne comporte pas de frais généraux supplémentaires.

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

    Cela permettra d'assurer que les données sont actualisées en fonction sur l'intervalle d'actualisation et il n'a pas besoin d'actualisation asynchrone .

    OriginalL'auteur prashant