जावा में पुनरावृत्ति निवारण और आलसी कम्प्यूटिंग

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

public static void main(String[] args)
{
LazyValue<Integer> ultimateQuestionOfLife = new LazyValue<Integer>()
{
@Override
protected Integer update()
{
return findNewUltimateAnswer();
}
};

//
ultimateQuestionOfLife.invalidate();

// update()
System. out .println( "Answer is: " + ultimateQuestionOfLife.get());

// update() ,
System. out .println( "Answer is: " + ultimateQuestionOfLife.get());

//
ultimateQuestionOfLife.invalidate();

// update()
System. out .println( "Answer is: " + ultimateQuestionOfLife.get());
}

एक छोटे ईट्यूड कार्यक्रम में परीक्षण सफल रहे, जबकि इस वर्ग का उपयोग करने वाले एक बड़े काम के प्रोजेक्ट में एक स्टैक ओवरफ्लो त्रुटि दिखाई देने लगी - मानों ने एक दूसरे को सूचना के किसी अन्य स्रोत के बिना अपडेट किया। यदि हर बार पुनर्गणना हुई और अंतिम क्षण में नहीं, तो यह त्रुटि नहीं होगी।

private static LazyValue<Integer> lv1 = new LazyValue<Integer>()
{
@Override
protected Integer update()
{
return lv2.get(); //
}
};

private static LazyValue<Integer> lv2 = new LazyValue<Integer>()
{
@Override
protected Integer update()
{
return lv1.get() + 1;
}
};

public static void main(String[] args)
{
// StackOverflowException
System. out .println(lv2.get());
}

बहुत जल्दी, मैं यहाँ और वहाँ पुनरावृत्ति को रोकने के लिए कोड में बैसाखी सम्मिलित करने के लिए थक गया, और मैंने कैशिंग क्लास में एक पुनरावृत्ति डिटेक्टर को एम्बेड करने का फैसला किया, जो काम करेगा, रिकर्स के "इंस्टिगेटर" को स्टैक को खोलना और कुछ डिफ़ॉल्ट मूल्य का उत्पादन करना, जिससे रोकना। StackOverflowException। यहाँ कार्यान्वयन है:

private static LazyValue<Integer> lv1 = new RSLazyValue<Integer>()
{
@Override
protected Integer update()
{
return lv2.get();
}

@Override
protected Integer getDefault()
{
return 0;
}
};

private static LazyValue<Integer> lv2 = new RSLazyValue<Integer>()
{
@Override
protected Integer update()
{
return lv1.get() + 1;
}

@Override
protected Integer getDefault()
{
return 10;
}
};

public static void main(String[] args)
{
// 10
System. out .println(lv2.get());
}

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

public ValueType get()
{
// update() ,
// , get()
// update()
if (updateInProgress)
throw new RecursionDetectedException( this );

// update()
if (isInvalid)
{
// update()
updateInProgress = true ;
try
{
//
value = update();

// isInvalid false update()
//
isInvalid = false ;
}
catch (RecursionDetectedException e)
{
if (e.getRecursionStarter() != this )
throw e; // ,
else
return getDefault(); // -
}
finally
{
// , get()
updateInProgress = false ;
}
}

return value;
}

समाधान ने एक बड़ी परियोजना में बहुत समय बचाने की अनुमति दी। प्रोग्रामर और प्रोसेसर दोनों का समय। प्रदर्शन की बचत यह है कि डेटा की गणना केवल मांग पर की जाती है, और यदि अनुरोध नहीं हुआ है, तो यह डेटा किसी के लिए आवश्यक है और आपको इसे पढ़ने की आवश्यकता नहीं है। मुझे उम्मीद है कि ये 2 छोटी कक्षाएं आपका समय बचाएंगी। मुझे रचनात्मक आलोचना और उन मामलों में खुशी होगी, जिनमें "कुछ भी काम नहीं करता है।"

पूर्ण वर्ग कोड:
LazyValue.java
RSLazyValue.java