రెండు రకాల ఇరేటర్లకు మద్దతు ఇవ్వండి, మొదటిది వేగంగా విఫలమవుతుంది మరియు రెండవది సురక్షితంగా విఫలమవుతుంది. జావాలో మినహాయింపు నిర్వహణ విషయానికి వస్తే ఇవి కీలక పాత్ర పోషిస్తాయి. ‘ఫెయిల్ అండ్ ఫెయిల్ సేఫ్ ఇటేరేటర్స్’ పై ఈ వ్యాసంలో, మేము రెండు ఇరేటర్స్ యొక్క పనితో పాటు వాటి మధ్య అవసరమైన వ్యత్యాసాన్ని విశ్లేషిస్తాము.
ఈ వ్యాసంలో చర్చించాల్సిన గమనికలు క్రిందివి:
- ఏకకాలిక మార్పులు
- ఫాస్ట్ ఇటరేటర్ విఫలమైంది
- సేఫ్ ఇటరేటర్ విఫలమైంది
- ఫెయిల్ vs ఫెయిల్ సేఫ్ ఇటేరేటర్ విఫలం
వివరణాత్మక వివరణలోకి రాకముందు, ఏకకాలిక సవరణ భావనతో మనల్ని పరిచయం చేసుకోవచ్చు.
ఏకకాలిక మార్పు
ఒకే థ్రెడ్ (లేదా బహుళ థ్రెడ్‌లు), సేకరణపై మళ్ళించినప్పుడు, సేకరణలోని మూలకాన్ని జోడించడం లేదా తొలగించడం ద్వారా లేదా మూలకం యొక్క విలువను ఒక నిర్దిష్ట స్థానంలో నవీకరించడం ద్వారా సేకరణ యొక్క నిర్మాణాన్ని మార్చవచ్చు. ఈ ప్రక్రియను ఏకకాలిక మార్పు అంటారు.
ఒకే వివరాల్లోకి రాకముందు, అంశానికి పైన ఉన్న రెండు వ్యవస్థలను త్వరగా పరిశీలిద్దాం,
ఫాస్ట్ సిస్టం విఫలమైంది:
లోపం సంభవించిన వెంటనే మూసివేస్తే, సిస్టమ్ ఫెయిల్ ఫాస్ట్ సిస్టమ్ అని లేబుల్ చేయబడుతుంది. కార్యకలాపాలు తక్షణమే రద్దు చేయబడతాయి మరియు వైఫల్యాలు లేదా లోపాలు బహిర్గతమవుతాయి.
సురక్షిత వ్యవస్థ విఫలమైంది:
లోపం లేదా లోపం సంభవించిన తర్వాత కూడా అవి పనిచేయడం కొనసాగిస్తే, సిస్టమ్ విఫలమైన సురక్షిత వ్యవస్థగా ముద్రించబడుతుంది. వారు ఆపరేషన్‌ను నిలిపివేయరు మరియు లోపాలను బహిర్గతం చేయడానికి బదులుగా వాటిని దాచరు.
జావాలోని ఇటిరేటర్లు కలెక్షన్ వస్తువులపై ప్రయాణించడానికి మాకు అనుమతిస్తాయి. సేకరణ ద్వారా తిరిగి వచ్చిన ఇరేటర్లు వేగంగా విఫలమవుతాయి లేదా ప్రకృతిలో సురక్షితంగా విఫలమవుతాయి.
ఫాస్ట్ ఇటరేటర్ విఫలమైంది
జావాలోని ఫాస్ట్ ఇటెరేటర్లు విఫలమైతే సేకరణకు ఏ విధమైన నిర్మాణాత్మక మార్పులను అనుమతించవు. నిర్మాణాత్మక సవరణలో సేకరణలోని ఏదైనా మూలకాన్ని దానిపై మళ్ళించేటప్పుడు జోడించడం, తొలగించడం లేదా నవీకరించడం ఉంటాయి. పునరుక్తి ప్రక్రియలో సేకరణ నిర్మాణాత్మకంగా సవరించబడితే, మళ్ళి ఒక ఏకకాలిక మోడిఫికేషన్ ఎక్సెప్షన్‌ను విసురుతాడు.
ఏదేమైనా, ఐటెరేటర్స్ సొంత పద్ధతిని ఉపయోగించి ఒక వస్తువు తీసివేయబడితే, అంటే తొలగించు () పద్ధతిని ఉపయోగించి, మినహాయింపు విసిరివేయబడదని గమనించాలి. ఇది పూర్తిగా సురక్షితమైన ప్రక్రియ. మీరు కలిగి ఉన్నారని నిర్ధారించుకోండి జావా ఇన్‌స్టాల్ చేయబడింది మీ సిస్టమ్‌లో
ఫెయిల్ ఫాస్ట్ ఇటిరేటర్ యొక్క ఉదాహరణ:
దిగుమతి java.util.HashMap దిగుమతి java.util.Iterator దిగుమతి java.util.Map పబ్లిక్ క్లాస్ FailFastExample {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {మ్యాప్ monthIndex = new HashMap () monthIndex.put ('1', 'జనవరి ') monthIndex.put (' 2 ',' ఫిబ్రవరి ') monthIndex.put (' 3 ',' March ') 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 (తెలియని మూలం)
శ్రేణి c ++ ను క్రమబద్ధీకరించండి
ఇప్పుడు మనం ముందుకు వెళ్లి ఫెయిల్ సేఫ్ ఇటేరేటర్‌ని చూద్దాం,
సేఫ్ ఇటరేటర్ విఫలమైంది
ఫెయిల్ ఫాస్ట్ ఇరేటర్స్ మాదిరిగా కాకుండా, పునరావృత ప్రక్రియలో సేకరణ సవరించబడితే ఫెయిల్ సేఫ్ ఇరేటర్స్ ఎటువంటి మినహాయింపులను ఇవ్వరు. అసలు సేకరణకు బదులుగా అవి సేకరణ యొక్క క్లోన్ మీద మళ్ళించటం దీనికి కారణం. వాస్తవ సేకరణలో చేసిన నిర్మాణాత్మక మార్పులు వారిచే గుర్తించబడవు.
అయితే, నిజంగా ఫెయిల్ సేఫ్ ఇటేరేటర్ లాంటిదేమీ లేదని గమనించాలి. దీనిని బలహీనంగా-స్థిరంగా పేర్కొనడం సముచితం. దీని అర్థం ఉంటే పునరావృత ప్రక్రియలో ఒక సేకరణ సవరించబడుతుంది, ఇటేరేటర్ చూసేది బలహీనంగా హామీ ఇవ్వబడుతుంది. ఈ ప్రవర్తన వేర్వేరు సేకరణలకు భిన్నంగా ఉంటుంది మరియు జావాడోక్స్‌లో నమోదు చేయబడింది.
ఫెయిల్ సేఫ్ ఇటిరేటర్ యొక్క ఉదాహరణ:
పబ్లిక్ క్లాస్ FailSafeExample {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {కంకరెంట్ మ్యాప్ నెలఇండెక్స్ = కొత్త కంకరెంట్ హాష్ మ్యాప్ () నెలఇండెక్స్.పుట్ ('1', 'జనవరి') నెలఇండెక్స్.పుట్ ('2', 'ఫిబ్రవరి') నెలఇండెక్స్.పుట్ ( '3', 'మార్చి') ఇటిరేటర్ ఇటెరేటర్ = నెలఇండెక్స్.కీసెట్ (). ఇరేటర్ () అయితే (iterator.hasNext ()) {System.out.println (monthIndex.get (iterator.next ())) monthIndex.put ( '4', 'ఏప్రిల్')}}}అవుట్పుట్:
- జనవరి
- ఫిబ్రవరి
- మార్చి
చివరగా ఈ వ్యాసంలో మేము ఈ ఇటరేటర్లను పోల్చి చూస్తాము,
తేడాలు: ఫాస్ట్ మరియు ఫెయిల్ సేఫ్ ఇటేరేటర్
రెండు ఇటరేటర్ల మధ్య ముఖ్యమైన తేడాలు క్రింద ఇవ్వబడ్డాయి:
| పారామితులు | ఫాస్ట్ ఇటరేటర్ విఫలమైంది | సేఫ్ ఇటరేటర్ విఫలమైంది |
| ఏకకాలిక మోడిఫికేషన్ మినహాయింపు త్రో | అవును, ఒక సేకరణ దానిపై మళ్ళించేటప్పుడు సవరించబడితే అవి CocurrentModificationExcepti-on ను విసిరివేస్తాయి. | లేదు, ఒక సేకరణ దానిపై మళ్ళించేటప్పుడు సవరించబడితే వారు మినహాయింపు ఇవ్వరు. |
| సేకరణను క్లోన్ చేయండి | లేదు, వారు మూలకాలపై ప్రయాణించడానికి అసలు సేకరణను ఉపయోగిస్తారు. | అవును, వారు అసలు సేకరణ యొక్క కాపీని ప్రయాణించడానికి ఉపయోగిస్తారు. |
| మెమరీ ఓవర్ హెడ్ | లేదు, వారికి అదనపు మెమరీ అవసరం లేదు. | అవును, సేకరణను క్లోన్ చేయడానికి వారికి అదనపు మెమరీ అవసరం. |
| ఉదాహరణలు | హాష్ మ్యాప్, వెక్టర్, అర్రేలిస్ట్, హాష్సెట్ | CopyOnWriteArrayList |
జావా యొక్క బహుముఖ భాషలో ఈ ఇటరేటర్లు ప్రత్యేకమైనవి మరియు చాలా అవసరం. ఫెయిల్ సేఫ్ దానికి ఓదార్పునిచ్చే రింగ్ కలిగి ఉన్నప్పటికీ, ఫెయిల్ ఫాస్ట్ ఇరేటర్ బలంగా ఉందని రుజువు చేస్తుంది.
ఇది ఈ వ్యాసం చివరికి తెస్తుంది. ఒకవేళ మీరు మరింత తెలుసుకోవాలనుకుంటే అప్పుడు చూడండి ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు మీకు జావా ప్రోగ్రామింగ్‌లోకి రావడానికి మరియు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.
మాకు ప్రశ్న ఉందా? దయచేసి ఈ “ఫెయిల్ ఫాస్ట్ వర్సెస్ ఫెయిల్ సేఫ్” బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.