वहाँ किसी भी कारण से आलसी आरंभीकरण जावा में नहीं बनाया जा सकता है?

10

चूंकि मैं एक सर्वर पर काम कर रहा हूं, जो उपयोगकर्ताओं के लिए बिल्कुल गैर-जारी राज्य नहीं है, हमारे पास प्रत्येक उपयोगकर्ता-संबंधित वस्तु हमारे पास प्रत्येक अनुरोध पर लुढ़की हुई है।

नतीजतन, मैं अक्सर खुद को उन वस्तुओं के गुणों का आलसीकरण करने लगता हूं जो अप्रयुक्त हो सकती हैं।

protected EventDispatcher dispatcher = new EventDispatcher();

हो जाता है ...

protected EventDispatcher<EventMessage> dispatcher;

public EventDispatcher<EventMessage> getEventDispatcher() {
    if (dispatcher == null) {
        dispatcher = new EventDispatcher<EventMessage>();
    }
    return dispatcher;
}

क्या इसका कोई कारण है कि इसे जावा में नहीं बनाया जा सकता है?

protected lazy EventDispatcher dispatcher = new EventDispatcher();

जैसा कि टिप्पणियों में नीचे उल्लेख किया गया है, मुझे लगता है कि एक भाषा सैद्धांतिक रूप से विकसित हो सकती है जिसमें आप सबसे अधिक चाहते हैं। मैं संभावना के व्यावहारिक माप की तलाश कर रहा हूं। क्या अन्य सुविधाओं के साथ यह संघर्ष होगा? क्या कार्यान्वयन सरल है जेवीएम के साथ काम करने के लिए पर्याप्त है क्योंकि यह मौजूद है? और भी, क्या यह एक अच्छा विचार है?

— निकोल
स्रोत

2

dunno लेकिन उदाहरण कोड थ्रेड-सुरक्षित नहीं है

— आर्मंड

2

@ synchronizedयदि वह विधि पर था, तो कीवर्ड उसी तरह काम करेगा। मुझे लगता है कि अधिक जटिल निर्माण विधियों के कुछ आवास होंगे। मेरे विशिष्ट उपयोग के मामले में, समस्या की प्रकृति के कारण, हर अनुरोध के साथ, क्योंकि यह स्वयं की दुनिया है, सिंक्रनाइज़ किया गया व्यर्थ है।

— निकोल

C # आलसी में एक पुस्तकालय में है, लेकिन यह भाषा द्वारा समर्थित है। sankarsan.wordpress.com/2009/10/04/laziness-in-c-4-0-lazyt क्या लैम्ब्डा और डेलिगेट्स और क्लोजर हैं? वैसे, आप इसे SO पर पूछना चाहते हैं, ताकि जॉन स्कीट और सह। अपनी बुद्धि साझा कर सकते हैं।

— नौकरी

3

आप किसी भी भाषा में बहुत कुछ बना सकते हैं। लेकिन जटिलता बजट और फीचर सूची सीमित हैं और भाषा डिजाइनर केवल वही शामिल कर सकते हैं जो वे सबसे महत्वपूर्ण मानते हैं (ठीक है, लैरी वॉल को छोड़कर - विशेष रूप से पर्ल 6 उर्फ "आपके सभी प्रतिमान हमारे हैं।")।

1

मूलभूत समस्या यह है कि जावा एकमात्र वैधानिक रूप से टाइप की गई भाषा है जिसमें कोई मेटा-प्रोग्रामिंग सुविधा नहीं है। सी में आप इसे दस मिनट में एक मैक्रो के रूप में लिख सकते हैं। C ++ में आप इसे लगभग दो मिनट में एक टेम्पलेट के रूप में लिख सकते हैं। जावा में आप कर सकते हैं ... पेस्ट और संशोधित करें।

— केविन क्लाइन

14

यहाँ आपके प्रश्न का आठ पेज का उत्तर है: http://tinlizzie.org/~awarth/papers/fool0.pdf

अगर मैं कोशिश कर सकता हूं और आलस्य को जोड़ने के साथ समस्याओं का संक्षेप कर सकता हूं, तो यह कोने के मामले हैं। साइड-इफेक्ट्स के आसपास बहुत सारे कैवेट हैं। अपने उदाहरण पर गौर करें, यदि निर्माणकर्ता के पास एक वैश्विक काउंटर को टक्कर देने या I / O करने जैसे साइड-इफेक्ट्स दिखाई देते हैं ... तो ऐसा कब होगा, इसके बारे में तर्क करना मुश्किल है। या अपवादों के बारे में भी बदसूरत दुष्प्रभाव पर विचार करें (जब उन्हें फेंक दिया जाता है ... जब आप आलसी वस्तु का संदर्भ देते हैं?)

बस उपरोक्त पेपर में सेक्शन 6 पर जाएं। (और आपके द्वारा छोड़े गए पृष्ठों पर सभी प्रकार की प्रणाली औपचारिक तर्क की प्रशंसा करें ...)

— पीटी
स्रोत

इस उत्तर को गहराई के कारण स्वीकार करते हुए कि पेपर इस सुविधा को संबोधित करता है। धन्यवाद!

— निकोल

टीएल; डीआर जब आप प्रोग्राम करते हैं, तो आपको यह जानना होगा कि आलसीपन के साथ साइड-इफेक्ट्स को रोकने के लिए क्या होता है, यह वास्तव में हाथ से बाहर निकल सकता है। यदि आप हाइबरनेट को जानते हैं और कुछ लोगों को इससे कितनी परेशानी है, तो बस पूरी भाषा के लिए एक ही कल्पना करें।

— वालफ्रैट

10

बेशक यह संभव है। वास्तव में, स्काला में पहले से ही यह सुविधा है! (स्काला एक JVM भाषा है और बाइटकोड के लिए संकलित है)। यहाँ scala स्रोत का एक टुकड़ा है:

class Foo {
  lazy val bar = "Hello World"
}

और यहाँ संकलित कोड का एक मध्यवर्ती रूप दिखता है:

scalac -Xprint:icode Foo.scala

[[syntax trees at end of icode]]// Scala source: Foo.scala
package <empty> {
  class Foo extends java.lang.Object with ScalaObject {
    @volatile protected var bitmap$0: Int = 0;
    lazy private[this] var bar: java.lang.String = _;
    <stable> <accessor> lazy def bar(): java.lang.String = {
      if (Foo.this.bitmap$0.&(1).==(0))
        {
          Foo.this.synchronized({
            if (Foo.this.bitmap$0.&(1).==(0))
              {
                Foo.this.bar = "Hello World";
                Foo.this.bitmap$0 = Foo.this.bitmap$0.|(1);
                ()
              };
            scala.runtime.BoxedUnit.UNIT
          });
          ()
        };
      Foo.this.bar
    };
    def this(): Foo = {
      Foo.super.this();
      ()
    }
  }

}

— oxbow_lakes
स्रोत

तो प्रोग्रामर.स्टैकएक्सचेंज . com/a/110958/24257 पर पीटी के जवाब के साथ यह कैसे सामंजस्य स्थापित करेगा ?

— पचेरियर

6

मुझे लगता है कि आपको सबसे पहले जावा लैंगगेट में वास्तविक गुणों को जोड़ना होगा, बजाय कि गेटएक्स / सेटएक्स मुहावर पर भरोसा करने के। इस तरह आप संपत्ति को आलसी (और सिंक्रनाइज़, आसानी से आदि ...) के रूप में चिह्नित कर सकते हैं।

यहां जो मांगा गया है, उसे छांटें (उद्देश्य-सी, लेकिन अवधारणा लागू होती है)।

— मार्टिन विकमैन
स्रोत

0

बेशक, यह जावा में जोड़ा जा सकता है, आलसी शब्द को सिंटैक्टिक चीनी के रूप में लागू किया जा सकता है। हालाँकि, इसे लागू किया जाना कंपाइलर बिल्डरों की दृष्टि पर निर्भर करता है।

— मिचेल ओवरिम
स्रोत