क्या जावा 8 ने आपूर्तिकर्ताओं के लिए कैश समर्थन किया है?

Question

अमरूद पुस्तकालय का अपना Supplier है जो जावा 8 Supplier का विस्तार नहीं करता है। इसके अलावा अमरूद आपूर्तिकर्ताओं के लिए एक कैश प्रदान करता है - Suppliers#memoize।

क्या कुछ समान है, लेकिन जावा 8 प्रदायक के लिए?

Answer 1

कोई Memoization के लिए निर्मित है जावा समारोह है, हालांकि यह बहुत मुश्किल, इसे लागू करने के इस तरह उदाहरण के लिए, नहीं है:

public static <T> Supplier<T> memoize(Supplier<T> delegate) { 
    AtomicReference<T> value = new AtomicReference<>(); 
    return() -> { 
     T val = value.get(); 
     if (val == null) { 
      val = value.updateAndGet(cur -> cur == null ? 
        Objects.requireNonNull(delegate.get()) : cur); 
     } 
     return val; 
    }; 
} 

ध्यान दें कि विभिन्न कार्यान्वयन दृष्टिकोण मौजूद हैं। उपर्युक्त कार्यान्वयन प्रतिनिधि को कई बार कॉल कर सकता है यदि ज्ञापन सप्लायर विभिन्न धागे से कई बार अनुरोध करता है। कभी-कभी लॉक के साथ स्पष्ट सिंक्रनाइज़ेशन पर ऐसे कार्यान्वयन को प्राथमिकता दी जाती है। ताला पसंद किया जाता है, तो DCL इस्तेमाल किया जा सकता है:

public static <T> Supplier<T> memoizeLock(Supplier<T> delegate) { 
    AtomicReference<T> value = new AtomicReference<>(); 
    return() -> { 
     T val = value.get(); 
     if (val == null) { 
      synchronized(value) { 
       val = value.get(); 
       if (val == null) { 
        val = Objects.requireNonNull(delegate.get()); 
        value.set(val); 
       } 
      } 
     } 
     return val; 
    }; 
} 

यह भी ध्यान रखें, के रूप में @LouisWasserman सही ढंग से टिप्पणी में उल्लेख किया है, तो आप आसानी से अमरूद आपूर्तिकर्ता में JDK आपूर्तिकर्ता बदल सकता है और इसके विपरीत विधि संदर्भ का उपयोग करते हुए:

java.util.function.Supplier<String> jdkSupplier =() -> "test"; 
com.google.common.base.Supplier<String> guavaSupplier = jdkSupplier::get; 
java.util.function.Supplier<String> jdkSupplierBack = guavaSupplier::get; 

तो गुवा और जेडीके कार्यों के बीच स्विच करने की कोई बड़ी समस्या नहीं है।

Answer 2

सरल समाधान

public static <T> Supplier<T> memoize(Supplier<T> original) { 
    ConcurrentHashMap<Object, T> store=new ConcurrentHashMap<>(); 
    return()->store.computeIfAbsent("dummy", key->original.get()); 
} 

होगा हालांकि, सबसे सरल हमेशा सबसे कारगर नहीं है।

आप एक स्वच्छ और कुशल समाधान चाहते हैं, एक गुमनाम आंतरिक वर्ग का सहारा धारण करने के लिए परिवर्तनशील राज्य बंद का भुगतान करेगा:

public static <T> Supplier<T> memoize1(Supplier<T> original) { 
    return new Supplier<T>() { 
     Supplier<T> delegate = this::firstTime; 
     boolean initialized; 
     public T get() { 
      return delegate.get(); 
     } 
     private synchronized T firstTime() { 
      if(!initialized) { 
       T value=original.get(); 
       delegate=() -> value; 
       initialized=true; 
      } 
      return delegate.get(); 
     } 
    }; 
} 

यह एक प्रतिनिधि आपूर्तिकर्ता जो पहली बार आपरेशन करते हैं और बाद में होगा उपयोग करता है, अपने आप को एक आपूर्तिकर्ता के साथ प्रतिस्थापित करें जो पहले मूल्यांकन के कब्जे वाले परिणाम को बिना शर्त रूप से लौटाता है। चूंकि इसमें final फ़ील्ड सेमेन्टिक्स हैं, इसलिए बिना किसी अतिरिक्त सिंक्रनाइज़ेशन के इसे बिना शर्त रूप से वापस किया जा सकता है।

synchronized विधि firstTime() के अंदर, वहाँ अभी भी एक initialized ध्वज की जरूरत है क्योंकि प्रारंभ दौरान समवर्ती पहुंच के मामले में, एक से अधिक थ्रेड विधि के प्रवेश पर प्रतीक्षा कर सकते हैं इससे पहले कि प्रतिनिधि प्रतिस्थापित किया गया है है। इसलिए, इन धागे को यह पता लगाने की आवश्यकता है कि प्रारंभिकता पहले ही हो चुकी है। बाद के सभी एक्सेस नए प्रतिनिधि सप्लायर को पढ़ेंगे और मूल्य जल्दी प्राप्त करेंगे।