तेजी से और असफल जावा में सुरक्षित Iterators: क्या अंतर है?

Article फेल फास्ट एंड फेल सेफ इटरेटर्स ’पर यह लेख आपको प्रासंगिक उदाहरणों के साथ इन दो इटरेटर की तुलना करने में मदद करेगा।

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

इस लेख में चर्चा किए जाने वाले बिंदु निम्नलिखित हैं:





एक विस्तृत विवरण में जाने से पहले, अपने आप को समवर्ती संशोधन की अवधारणा से परिचित कराएं।

समवर्ती संशोधन

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



आइए हम जल्दी ही दो प्रणालियों पर एक नज़र डालते हैं जो विषय के ऊपर चिंता करते हैं, उसी के विवरण में आने से पहले,

विफल फास्ट Sysetm:

एक सिस्टम को एक असफल फास्ट सिस्टम लेबल किया जाता है, अगर यह त्रुटि की घटना के तुरंत बाद बंद हो जाता है। ऑपरेशन तुरंत समाप्त हो जाते हैं और विफलताएं या त्रुटियां सामने आती हैं।

विफल सुरक्षित प्रणाली:

एक सिस्टम को एक असफल सुरक्षित प्रणाली कहा जाता है, अगर वे एक गलती या एक त्रुटि होने के बाद भी काम करना जारी रखते हैं। वे किसी ऑपरेशन को रद्द नहीं करते हैं और त्रुटियों को उजागर करने के बजाय छिपाते हैं।



बड़े डेटा विश्लेषण के अनुप्रयोग

जावा में Iterators हमें संग्रह वस्तुओं पर पार करने की अनुमति देते हैं। संग्रह द्वारा लौटाए गए पुनरावृत्तियों या तो तेजी से विफल होते हैं या प्रकृति में सुरक्षित विफल होते हैं।

विफल फास्ट Iterator

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

हालांकि, यह ध्यान दिया जाना चाहिए कि यदि कोई आइटम पुनरावृत्तियों का उपयोग करके अपने तरीके से हटा दिया जाता है यानी हटा () विधि, कोई अपवाद नहीं फेंका जाता है। यह पूरी तरह से सुरक्षित प्रक्रिया है। आप सुनिश्चित करें कि आपके पास जावा स्थापित आपके सिस्टम पर

विफल फास्ट Iterator का उदाहरण:

आयात java.util.ashMap आयात java.util.Iterator आयात java.util.Map सार्वजनिक वर्ग FailFastExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग [] args) {मानचित्र महीनाइंडैक्स = नया कैश () महीनाइंडेक्स ('1', 'जनवरी) ') महीनाइंडेक्स.पुट (' 2 ',' फरवरी ') महीनाइंडेक्स.पुट (' 3 ',' मार्च ') Iterator iterator = monthIndex.keySet ()) iterator () जबकि (iterator .hasNext ()) {System.out। .println (monthIndex.get (iterator.next ())) // मैप में एक तत्व जोड़ना // अपवाद अगले (//) विधि के अगले कॉल // पर फेंक दिया जाएगा। monthIndex.put ('4', 'अप्रैल')}}}}

आउटपुट:

थ्रेड में अपवाद 'मुख्य' java.util.ConcurrentModificationException

java.util.HashMap $ HashIterator.nextEntry (अज्ञात स्रोत) पर

अब हम आगे बढ़ते हैं और Fail Safe Iterator पर एक नज़र डालते हैं,

फेल सेफ इटरेटर

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

हालांकि, यह ध्यान दिया जाना चाहिए कि वास्तव में फेल सेफ इटरेटर जैसी कोई चीज नहीं है। इसे कमजोर-संगत करार देना उचित होगा। इसका सीधा सा मतलब है कि अगर पुनरावृत्ति की प्रक्रिया के दौरान एक संग्रह को संशोधित किया जाता है, जो Iterator देखता है कि इसकी गारंटी है। यह व्यवहार अलग-अलग संग्रहों के लिए अलग-अलग होता है और इसे Javadocs में प्रलेखित किया जाता है।

असफल सुरक्षित Iterator का उदाहरण:

सार्वजनिक वर्ग FailSafeExample {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग [] args) {ConcurrentMap monthIndex = नया ConcurrentHashMap () माहIndex.put ('1', 'जनवरी') monthIndex.put ('2', 'फरवरी') monthIndex.put ( '3', 'मार्च') Iterator iterator = monthIndex.keySet ()। Itter () जबकि (iterator.hasNext ()) {System.out.println (monthIndex.get (iterator.next ())) monthIndex.put () '4', 'अप्रैल')}}}

आउटपुट:

  • जनवरी
  • फरवरी
  • मार्च

अंत में इस लेख में हम इन पुनरावृत्तियों की तुलना करेंगे,

अंतर: तेजी से और विफल सुरक्षित Iterator

नीचे दिए गए दो पुनरावृत्तियों के बीच आवश्यक अंतर हैं:

पैरामीटर विफल फास्ट Iterator फेल सेफ इटरेटर
समवर्ती फेंकना अपवाद

हाँ, वे CocurrentModificationExcepti-on को फेंक देते हैं यदि कोई संग्रह इसे संशोधित करते समय संशोधित किया जाता है।

नहीं, वे कोई अपवाद नहीं फेंकते हैं यदि एक संग्रह को संशोधित किया जाता है, जबकि उस पर पुनरावृत्ति होती है।

संग्रह क्लोन

नहीं, वे तत्वों पर पार पाने के लिए मूल संग्रह का उपयोग करते हैं।

हां, वे मूल संग्रह की प्रतिलिपि का उपयोग करते हैं।

मेमोरी ओवरहेड

नहीं, उन्हें अतिरिक्त मेमोरी की आवश्यकता नहीं है।

हां, उन्हें संग्रह को क्लोन करने के लिए अतिरिक्त मेमोरी की आवश्यकता होती है।

उदाहरण

HashMap, वेक्टर, ArrayList, HashSet

CopyOnWriteArrayList

इन पुनरावृत्तियों को जावा की बहुमुखी भाषा में अद्वितीय और बहुत आवश्यक दोनों हैं। हालाँकि, सुरक्षित सुरक्षित होने से इसमें एक आराम देने वाली अंगूठी होती है, लेकिन विफल तेज़ पुनरावृत्ति करने वाला मजबूत साबित होता है।

यह इस लेख के अंत में लाता है। यदि आप अधिक सीखना चाहते हैं तो बाहर की जाँच करें Edureka द्वारा। एडुर्का के जावा जे 2 ईई और एसओए प्रशिक्षण और प्रमाणन पाठ्यक्रम आपको जावा प्रोग्रामिंग में एक शुरुआत देने के लिए डिज़ाइन किया गया है और आपको हाइबरनेट और स्प्रिंग जैसे विभिन्न जावा फ्रेमवर्क के साथ कोर और उन्नत जावा अवधारणाओं दोनों के लिए प्रशिक्षित करता है।

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