गैर-कैश किए गए मान को कई बार लोड करने से कैसे रोकें?

Question

कुशल में कई बार कैश में मौजूद मान को लोड करने से रोकने के लिए कैसे?

एक ठेठ कैश उपयोग निम्नलिखित स्यूडोकोड है:

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

समस्या: से पहले मूल्य सेवा (डाटाबेस, WebService, RemoteEJB या कुछ और) से भरी हुई है दूसरी कॉल एक ही समय में किया जा सकता , जो एक बार फिर मूल्य लोड हो जाएगा।

उदाहरण के लिए, जब मैं उपयोगकर्ता एक्स के लिए सभी आइटम कैश कर रहा हूं, और इस उपयोगकर्ता को अक्सर देखा जाता है, और कई आइटम होते हैं, तो उसके सभी आइटमों के भार को एक साथ कॉल करने की उच्च संभावना होती है, जिसके परिणामस्वरूप सर्वर पर भारी भार होता है ।

मैं get फ़ंक्शन सिंक्रनाइज़ कर सकता हूं, लेकिन इससे अन्य खोजों को प्रतीक्षा करने के लिए मजबूर किया जाएगा, और अधिक समझ नहीं आती है। मैं प्रत्येक कुंजी के लिए नया लॉक बना सकता हूं, लेकिन मुझे नहीं पता कि जावा में यह बड़ी संख्या में ताले प्रबंधित करने का अच्छा विचार है (यह हिस्सा भाषा विशिष्ट है, कारण मैंने इसे java के रूप में टैग किया है) ।

या कोई और तरीका है जिसका मैं उपयोग कर सकता हूं? यदि हां, तो सबसे कुशल क्या होगा?

Answer 1

पहिया बदलने मत करो, का उपयोग करें।

यदि आप एहचेचे का उपयोग कर रहे हैं, तो read-through पढ़ें, यह वह पैटर्न है जिसे आप पूछ रहे हैं। कैश को कैश मिस पर ऑब्जेक्ट्स को पढ़ने के लिए निर्देश देने के लिए आपको CacheEntryFactory इंटरफ़ेस को कार्यान्वित करना होगा, और SelfPopulatingCache के उदाहरण के साथ आपको Ehcache इंस्टेंस को लपेटना होगा।

Answer 2

कुछ सामान्य रूप से आप ऑब्जेक्ट के हैशकोड का उपयोग करना चाहते हैं।

आपके पास टकराव की संभावना को कम करने के लिए हैशकोड के आधार पर उपयोग किए जाने वाले ताले की एक श्रृंखला हो सकती है। या एक हैक के रूप में आप इस तथ्य का उपयोग कर सकते हैं कि ऑटो-बॉक्स किए गए बाइट हमेशा एक ही ऑब्जेक्ट लौटते हैं। अमरूद के LoadingCache या memoizing supplier

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

लोड होने के समय, परिणाम के बजाय नक्शे में एक मध्यवर्ती वस्तु डालें ताकि यह इंगित किया जा सके कि लोडिंग शुरू हो गई है लेकिन समाप्त नहीं हुई है। Java.util.concurrent.FutureTask के नीचे इंटरमीडिएट ऑब्जेक्ट के लिए उपयोग किया जाता है:

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; 
}`