अनंत लूप

कंप्यूटर प्रोग्रामिंग में, अनंत लूप (या अंतहीन लूप) निर्देशों का क्रम है, जो लिखित रूप में, अंतहीन रूप से जारी रहेगा, जब तक कि कोई बाहरी हस्तक्षेप नहीं होता (प्लग खींचो) है। यह इच्छानुरूप हो सकता है।

अवलोकन

यह इससे भिन्न है:

• एक प्रकार का कंप्यूटर प्रोग्राम जो निर्देश को लगातार तब तक चलाता है जब तक कि इसे बंद या बाधित नहीं किया जाता है।

निम्नलिखित स्यूडोकोड पर विचार करें:

how_many = 0
while is_there_more_data() do
    how_many = how_many + 1
end
display "the number of items counted = " how_many

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

birds = 1
fish = 2
while birds + fish > 1 do
    birds = 3 - birds
    fish = 3 - fish
end

बर्ड्स वैकल्पिक रूप से 1 या 2 होंगे, चूंकि फिश वैकल्पिक रूप से 2 या 1 होगी। लूप तब तक नहीं रुकेगा जब तक कि कोई बाहरी हस्तक्षेप नहीं होता (प्लग को खींचें) हैं।

विवरण

अनंत लूप कंप्यूटर प्रोग्राम में निर्देशों का क्रम है जो या तो लूप के बिना समाप्त होने वाली स्थिति के कारण अंतहीन रूप से लूप करता है, जिसमें कभी भी पूरा नहीं किया जा सकता है या जो लूप को फिर से प्रारंभ करने का कारण बनता है। सहकारी मल्टीटास्किंग के साथ पुराने ऑपरेटिंग प्रणाली में, अनंत लूप सामान्य रूप से पूरे प्रणाली को अनुत्तरदायी बना देते हैं। अब प्रचलित प्रीमेप्टिव मल्टीटास्किंग मॉडल के साथ, अनंत लूप सामान्यतः प्रोग्राम को सभी उपलब्ध प्रोसेसर समय का उपभोग करने का कारण बनते हैं, किन्तु सामान्यतः उपयोगकर्ता द्वारा इसे समाप्त किया जा सकता है। व्यस्त प्रतीक्षा लूप को कभी-कभी अनंत लूप भी कहा जाता है। कंप्यूटर फ्रीजिंग (कंप्यूटिंग) के लिए अनंत लूप संभावित कारण हैं; अन्य में थ्रैशिंग (कंप्यूटर विज्ञान), डेडलॉक और एक्सेस उल्लंघन सम्मिलित हैं।

उद्देश्य बनाम अनपेक्षित लूपिंग

लूपिंग निर्देशों का सेट दोहरा रहा है जब तक कि विशिष्ट शर्त पूरी नहीं हो जाती है। अनंत लूप तब होता है जब लूप की कुछ अंतर्निहित विशेषता के कारण स्थिति कभी पूरी नहीं होती है।

निश्चयपूर्वक लूपिंग

ऐसी कुछ स्थितियाँ होती हैं जब यह वांछित व्यवहार होता है। उदाहरण के लिए, कार्ट्रिज-आधारित गेम कंसोल पर सामान्यतः उनके मुख्य लूप में कोई निकास स्थिति नहीं होती है, क्योंकि कंसोल के बंद होने तक प्रोग्राम के लूप से बाहर निकलने के लिए कोई ऑपरेटिंग प्रणाली नहीं होता है।

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

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

मल्टी-थ्रेडिंग

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

अपरिचित में लूपिंग

प्रायः, इस शब्द का प्रयोग उन स्थितियों के लिए किया जाता है जब यह अभीष्ट परिणाम नहीं होता है; अर्थात् जब यह सॉफ्टवेयर बग है। नोविस प्रोग्रामरों में ऐसी त्रुटियां सबसे सामान्य हैं, किन्तु अनुभवी प्रोग्रामर द्वारा भी की जा सकती हैं, क्योंकि उनके कारण अधिक सूक्ष्म हो सकते हैं।

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

चूंकि कोड के गहन निरीक्षण से अधिकांश अनंत लूप पाए जा सकते हैं, यह निर्धारित करने के लिए कोई सामान्य विधि नहीं है कि क्या दिया गया प्रोग्राम कभी रुकेगा या हमेशा के लिए चलेगा; यह हॉल्टिंग समस्या की अनिश्चितता है।

व्यवधान

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

लैंग्वेज समर्थन

See also: बहाव को नियंत्रित करें

विभिन्न नियंत्रण प्रवाह निर्माणों का उपयोग करके अनंत लूपों को प्रायुक्त किया जा सकता है। सामान्यतः, असंरचित प्रोग्रामिंग में यह जम्प बैक अप (के लिए जाओ) होता है, चूंकि संरचित प्रोग्रामिंग में यह अनिश्चित लूप (चूंकि लूप) होता है जो या तो स्थिति को छोड़ कर या स्पष्ट रूप से इसे while (true) ... के रूप में सेट करके कभी समाप्त नहीं होता है।

कुछ लैंग्वेजेस में अनंत लूप के लिए विशेष रूप से अनिश्चित लूप से शर्त को हटाकर विशेष निर्माण होते हैं। उदाहरणों में एडा (loop ... end loop), फोरट्रान (DO ... END DO), गो (for { ... }), रूबी (loop do ... end), और रस्ट (loop { ... }) सम्मिलित हैं।

निश्चयपूर्वक अनंत किनारों के उदाहरण

साधारण उदाहरण (सी (प्रोग्रामिंग लैंग्वेज) में):

#include <stdio.h>

int main()
{
  for (;;) // or equivalently, while (1)
    ;  
  return 0;
}

अनंत for (;;) का रूप पारंपरिक है, जो सी प्रोग्रामिंग लैंग्वेज के मानक संदर्भ में दिखाई देता है, और प्रायः इसका स्पष्ट रूप से हमेशा के लिए उच्चारण किया जाता है।

यह लूप है जो अनंत लूप को बिना रुके प्रिंट करेगा।

1980 के दशक की बेसिक प्रोग्रामिंग लैंग्वेज में समान उदाहरण:

10 PRINT "INFINITE LOOP"
20 GOTO 10

डॉस बैच फ़ाइलों में समान उदाहरण:

:A
echo Infinite Loop
goto :A

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

while (true) {
    System.out.println("Infinite Loop");
}

बोर्न अगेन शैल में उदाहरण

for ((;;)); do
	echo "Infinite Loop"
done

रस्ट (प्रोग्रामिंग लैंग्वेज) में उदाहरण

loop {
    println!("Infinite loop");
}

अपरिचित अनंत लूप के उदाहरण

गणितीय त्रुटियाँ

यहाँ विसुअल बेसिक में अनंत लूप का उदाहरण दिया गया है:

dim x as integer
do while x < 5
  x = 1
  x = x + 1
loop

यह ऐसी स्थिति बनाता है जहां x कभी भी 5 से अधिक नहीं होता है क्योंकि लूप कोड की प्रारंभ में x कों 1 का मान दिया जाता है, इस प्रकार, लूप हमेशा 2 में समाप्त होता है और लूप कभी नहीं टूटता है। इसे x = 1 निर्देश को लूप के बाहर ले जाकर ठीक किया जा सकता है। अनिवार्य रूप से यह अनंत लूप क्या करता है कंप्यूटर को 5 तक पहुंचने तक 1 से 1 जोड़ने के लिए निर्देश देना है। चूंकि 1+1 हमेशा 2 के समान होता है, ऐसा कभी नहीं होता है। कुछ लैंग्वेजेस में, गणितीय प्रतीकों के बारे में प्रोग्रामर का संशय अपरिचित में अनंत लूप का कारण बन सकता है। उदाहरण के लिए, यहाँ C (प्रोग्रामिंग लैंग्वेज) में स्निपेट है:

#include <stdio.h>

int main(void)
{
   int a = 0;
   while (a < 10) {
      printf("%d\n", a);
      if (a = 5)
         printf("a equals 5!\n");
      a++;
   }
   return 0;
}

अपेक्षित आउटपुट 0 से 9 तक की संख्या है, जिसमें इंटरजेक्टेड "a समान 5!" 5 और 6 के बीच है। चूंकि, लाइन मेंif (a = 5)ऊपर, प्रोग्रामर ने = (असाइनमेंट) ऑपरेटर को == (समानता परीक्षण) ऑपरेटर के साथ भ्रमित कर दिया है। यह प्रोग्राम में a बिंदु पर 5 का मान असाइन करेगा। इस प्रकार, a कभी भी 10 तक आगे बढ़ने में सक्षम नहीं होता है, और यह लूप समाप्त नहीं हो सकता हैं।

राउंडिंग त्रुटियाँ

AMD Turion प्रोसेसर पर C आउटपुट:

x = 0.10000000149011611938

x = 0.20000000298023223877

x = 0.30000001192092895508

x = 0.40000000596046447754

x = 0.50000000000000000000

x = 0.60000002384185791016

x = 0.70000004768371582031

x = 0.80000007152557373047

x = 0.90000009536743164062

x = 1.00000011920928955078

x = 1.10000014305114746094

x = 1.20000016689300537109

...

समाप्ति की स्थिति का मानांकन करने में अप्रत्याशित व्यवहार भी इस समस्या का कारण बन सकता है। यहाँ C (प्रोग्रामिंग लैंग्वेज) में उदाहरण दिया गया है:

float x = 0.1;
while (x != 1.1) {
  printf("x = %22.20f\n", x);
  x += 0.1;
}

कुछ प्रणालियों पर, यह लूप अपेक्षा के अनुरूप दस बार निष्पादित होता है, किन्तु अन्य प्रणालियों पर यह कभी समाप्त नहीं होता है। समस्या यह है कि दो फ्लोटिंग पॉइंट मानों की त्रुटिहीन समानता के लिय लूप टर्मिनेटिंग कंडीशन (x!= 1.1) परीक्षण और जिस तरह से कई कंप्यूटरों में फ्लोटिंग पॉइंट वैल्यू का प्रतिनिधित्व किया जाता है, वह इस परीक्षण को विफल कर देगा, क्योंकि वे मान 0.1 का त्रुटिहीन रूप से प्रतिनिधित्व नहीं कर सकते हैं, इस प्रकार प्रत्येक वेतन वृद्धि (cf. बॉक्स) पर राउंडिंग त्रुटियों का परिचय देते हैं। पायथन (प्रोग्रामिंग लैंग्वेज) में भी ऐसा ही हो सकता है:

x = 0.1
while x != 1:
    print(x)
    x += 0.1

समानता या गैर-समानता के परीक्षणों की अप्रत्याशित रूप से विफल होने की संभावना के कारण, फ़्लोटिंग-पॉइंट मानों से निपटने के समय परीक्षण से अधिक या कम से अधिक का उपयोग करना सुरक्षित है। उदाहरण के लिए, यह परीक्षण करने के अतिरिक्त कि क्या x 1.1 के समान है, कोई यह परीक्षण कर सकता है कि क्या (x <= 1.0), या (x < 1.1) के समान है, जिनमें से कोई भी निश्चित संख्या में पुनरावृत्तियों के पश्चात बाहर निकलना निश्चित होता है। इस विशेष उदाहरण को ठीक करने का अन्य विधि पूर्णांक (कंप्यूटर विज्ञान) को नियंत्रण प्रवाह के रूप में उपयोग करना होता है, जो किए गए पुनरावृत्तियों की संख्या की गणना करता है।

इसी तरह की समस्या प्रायः संख्यात्मक विश्लेषण में होती है: निश्चित परिणाम की गणना करने के लिए, पुनरावृत्ति का विचार तब तक किया जाता है जब तक कि त्रुटि चुनी हुई सहनशीलता से छोटी नहीं होना चाहिए। चूंकि, पुनरावृत्ति के समय राउंडिंग त्रुटियों के कारण, निर्दिष्ट सहिष्णुता तक कभी नहीं पहुंचा जा सकता है, जिसके परिणामस्वरूप अनंत लूप होता है।

मल्टी-पार्टी लूप

अनंत लूप कई संस्थाओं के परस्पर क्रिया के कारण हो सकता है। सर्वर पर विचार करें जो हमेशा त्रुटि संदेश के साथ उत्तर देता है यदि वह अनुरोध को नहीं समझता है। यहां तक ​​​​कि यदि सर्वर के अन्दर अनंत लूप की कोई संभावना नहीं है, तो उनमें से दो (A और B) वाली प्रणाली अंतहीन रूप से लूप कर सकती है: यदि A को B से अज्ञात प्रकार का संदेश प्राप्त होता है, तो A त्रुटि संदेश के साथ B को उत्तर देता है। यदि B त्रुटि संदेश को नहीं समझता है, तो वह A को अपने स्वयं के त्रुटि संदेश के साथ उत्तर देता है; यदि A, B के त्रुटि संदेश को नहीं समझता है, तो वह और त्रुटि संदेश भेजता है, और इसी तरह आगे भी होता हैं।

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

छद्म-अनंत लूप

छद्म-अनंत लूप ऐसा लूप है जो अनंत दिखाई देता है किन्तु वास्तविक में यह बहुत लंबा लूप है।

बहुत बड़ी संख्या

बैश (यूनिक्स शेल) में उदाहरण:

for x in $(seq 1000000000); do
#loop code
done

असंभव समाप्ति की स्थिति

सी (प्रोग्रामिंग लैंग्वेज) में लूप के लिए उदाहरण:

unsigned int i;
for (i = 1; i != 0; i++) {
  /* loop code */
}

ऐसा प्रतीत होता है कि यह अनिश्चित काल तक चलेगा, किन्तु वास्तविक में इसका मान i अंततः unsigned int में संग्रहीत अधिकतम मान तक पहुंच जाएगा और उस संख्या में 1 जोड़ने से लूप को तोड़ते हुए 0 के आसपास लपेटा जाएगा। i की वास्तविक सीमा उपयोग किए गए प्रणाली और कंपाइलर के विवरण पर निर्भर करता है। स्वैच्छिक-त्रुटिहीन अंकगणित के साथ, यह लूप तब तक जारी रहेगा जब तक कि कंप्यूटर की मेमोरी (कंप्यूटर) i को होल्ड नहीं कर सकती, यदि i अहस्ताक्षरित पूर्णांक के अतिरिक्त हस्ताक्षरित पूर्णांक था, तो अतिप्रवाह अपरिभाषित होता है। इस स्थिति में, कंपाइलर कोड को अनंत लूप में अनुकूलित कर सकता है।

अनंत पुनरावर्तन

अनंत पुनरावर्तन अनंत लूप का विशेष स्थिति है जो पुनरावर्तन के कारण होता है।

अनुप्रयोगों के लिए विसुअल बेसिक में निम्न उदाहरण स्टैक ओवरफ़्लो त्रुटि देता है:

Sub Test1()
    Call Test1
End Sub

कथन का उल्लंघन

while (true)लूप पहली दृष्टि में अनंत दिखता है, किन्तु ब्रेक स्टेटमेंट या वापसी कथन के माध्यम से लूप से बचने की विधि हो सकती है।

पीएचपी में उदाहरण:

while (true) {
    if ($foo->bar()) {
        return;
    }
}

एल्डर्सन लूप

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

एल्डर्सन लूप का सी-जैसा स्यूडोकोड उदाहरण, जहां कार्यक्रम को उपयोगकर्ता द्वारा दी गई संख्याओं को शून्य तक दिए जाने तक माना जाता है, किन्तु जहां प्रोग्रामर ने गलत ऑपरेटर का उपयोग किया है:

int sum = 0;
int i;
while (true) {
   printf("Input a number to add to the sum or 0 to quit");
   i = getUserInput();
   if (i * 0) { // if i times 0 is true, add i to the sum. Note: ZERO means FALSE, Non-Zero means TRUE. "i * 0" is ZERO (FALSE)!
      sum += i; // sum never changes because (i * 0) is 0 for any i; it would change if we had != in the condition instead of *
   }
   if (sum > 100) {
      break;    // terminate the loop; exit condition exists but is never reached because sum is never added to
   }
}

इस शब्द को कथित तौर पर प्रोग्रामर (अंतिम नाम एल्डरसन) से अपना नाम मिला, जिसने 1996 में माइक्रोसॉफ्ट पहुंच में मोडल विंडो संवाद बॉक्स को ओके या कैंसल बटन के बिना कोडित किया था, जिससे जब भी बॉक्स आया तो पूरे प्रोग्राम को अक्षम कर दिया।

यह भी देखें

• साइकिल का पता लगाना
• गतिरोध
• डाइवर्जेंस (कंप्यूटर साइंस)
• कांटा बम (अनंत लूप दो प्रमुख घटकों में है)
• के लिए जाओ
• अनंत प्रतिगमन
• पुनरावृत्ति (कंप्यूटर विज्ञान)

बाहरी कड़ियाँ

• Make an infinite loop in several languages, on programming-idioms.org.