जावा में समय-समय पर ताज़ा कैश को लागू करना

Question

मेरा उपयोग केस एक सतत डीबी में संग्रहीत डेटा पर एक मेमोरी कैश को बनाए रखना है।

मैं यूआई पर प्रविष्टियों की सूची/मानचित्र को पॉप्युलेट करने के लिए डेटा का उपयोग करता हूं। किसी भी समय, यूआई पर प्रदर्शित डेटा जितना संभव हो उतना अपडेट किया जाना चाहिए (अच्छी तरह से यह कैश की ताज़ा आवृत्ति द्वारा किया जा सकता है)।

नियमित कैश कार्यान्वयन और इस विशेष कैश के बीच प्रमुख अंतर यह है कि इसे नियमित अंतराल पर सभी तत्वों के थोक ताज़ा करने की आवश्यकता होती है और इसलिए एलआरयू प्रकार के कैश से काफी अलग होता है।

मुझे जावा में यह कार्यान्वयन करने की आवश्यकता है और यदि कोई मौजूदा ढांचा है, तो इसका उपयोग किया जा सकता है जिसका उपयोग इसे चारों ओर बनाने के लिए किया जा सकता है।

मैंने Google Guava कैश लाइब्रेरी की खोज की है लेकिन यह थोक रीफ्रेश के बजाय प्रति प्रविष्टि ताज़ा करने के लिए अधिक उपयुक्त है। कोई आसान एपीआई नहीं है जो पूरे कैश पर रीफ्रेश करे।

किसी भी मदद की अत्यधिक सराहना की जाएगी।

इसके अलावा, यदि रीफ्रेश करने के लिए वृद्धि करना संभव है, तो यह बहुत अच्छा होगा क्योंकि पूरे कैश को ताज़ा करते समय केवल एक ही सीमा उत्पन्न होती है, यदि कैश आकार में बहुत बड़ा है, तो स्मृति ढेर कम से कम दो बार होना चाहिए नई प्रविष्टियों को लोड करने और पुराने मानचित्र को नए के साथ बदलने के लिए कैश का आकार। यदि कैश बढ़ता जा रहा है या एक चंकित ताज़ा है (बराबर आकार में ताज़ा करें) यह बहुत अच्छा होगा।

Answer 1

EHCache एक सुंदर पूर्ण विशेषताओं जावा कैशिंग पुस्तकालय है प्राप्त करना चाहते हैं। मुझे लगता है कि उनके पास ऐसा कुछ है जो आपके लिए काम करेगा।

कैश की वृद्धिशील रीलोड करने के लिए (जो कि किसी भी कैश पर काम करेगा), बस वर्तमान में लोड की गई प्रविष्टियों के माध्यम से पुन: प्रयास करें और उन्हें ताज़ा करें। (आप इस कार्य को पृष्ठभूमि शेड्यूलर पर चला सकते हैं)।

पूरे कैश को पुनः लोड करने के लिए मजबूर करने के विकल्प के रूप में, EHCache में एंट्री के लिए "टाइम-टू-लाइव" निर्दिष्ट करने की क्षमता है, इसलिए प्रविष्टियां स्वचालित रूप से फिर से लोड हो जाएंगी यदि वे बहुत पुरानी हैं।

Answer 2

बस इस वर्ग के वारिस, और loadDataFromDB और UpdateData लागू के रूप में आप 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

एक चीज जिसे जांचना है वह आवधिक रीफ्रेशिंग आवश्यक है? एक बार जब आप कैश से डेटा प्राप्त कर लेते हैं तो आप अपने रीफ्रेश लॉजिक को लागू कर सकते हैं, इससे किसी भी एसिंक्रोनस रीफ्रेशिंग की आवश्यकता को हटा दिया जाएगा और कैश की पुरानी प्रतियों को बनाए रखने की आवश्यकता को हटा दिया जाएगा। यह आईएमओ कैश डेटा रीफ्रेश करने का सबसे आसान और सबसे अच्छा तरीका है क्योंकि इसमें कोई अतिरिक्त ओवरहेड शामिल नहीं है।

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

यह है कि डेटा ताज़ा करने का अंतराल के आधार पर ताज़ा किया जाता है यह सुनिश्चित करना होगा और यह किसी भी अतुल्यकालिक ताज़ा जरूरत नहीं है।