stöder två typer av iteratorer, den första är fail snabbt och den andra är fail safe. Dessa spelar en viktig roll när det gäller undantagshantering i Java. I den här artikeln om ”Fail Fast And Fail Safe Iterators” kommer vi att analysera hur de två iteratorerna fungerar samt den väsentliga skillnaden mellan dem.
Nedan följer tips som ska diskuteras i den här artikeln:
lära sig steg för steg
Innan vi går in i en detaljerad förklaring kan vi bekanta oss med begreppet Concurrent Modification.
Samtidig modifiering
När en enskild tråd (eller flera trådar) går igenom en samling kan den ändra strukturen i samlingen, antingen genom att lägga till eller ta bort elementet i samlingen eller genom att uppdatera elementets värde på en viss position. Denna process är känd som samtidig modifiering.
Låt oss snabbt ta en titt på de två systemen som berör ovanstående ämne innan vi går in i detaljerna om samma,
Fail Fast Sysetm:
Ett system är märkt som ett felsnabbt system om det stängs av direkt efter att ett fel har inträffat. Åtgärderna avbryts omedelbart och felen eller felen exponeras.
Felsäkert system:
Ett system är märkt som ett felsäkert system om de fortsätter att fungera även efter att ett fel eller ett fel har inträffat. De avbryter inte en operation och döljer felen istället för att exponera dem.
Iteratorer i java tillåter oss att korsa över samlingsobjekten. Iteratorerna som returneras av samlingen misslyckas snabbt eller misslyckas säkert.
Fail Fast Iterator
Misslyckade snabb iteratorer i Java tillåter inte alla typer av strukturändringar i en samling medan den itererar över den. Strukturell modifiering inkluderar att lägga till, ta bort eller uppdatera något element i samlingen medan det går igenom det. Iteratorn kastar ett ConcurrentModificationException om en samling strukturellt modifieras under iterationsprocessen.
Det måste dock noteras att om ett objekt tas bort med iterators egen metod, dvs. metoden remove (), kastas inget undantag. Det är en helt säker process. se till att du har java installerat på ditt system
Exempel på Fail Fast Iterator:
importera java.util.HashMap importera java.util.Iterator import java.util.Map public class FailFastExample {public static void main (String [] args) {Map monthIndex = new HashMap () monthIndex.put ('1', 'January ') monthIndex.put (' 2 ',' February ') monthIndex.put (' 3 ',' March ') Iterator iterator = monthIndex.keySet (). iterator () medan (iterator.hasNext ()) {System.out .println (monthIndex.get (iterator.next ())) // lägga till ett element till Map // undantag kastas vid nästa samtal // av nästa () metod. monthIndex.put ('4', 'April')}}}Produktion:
Undantag i tråden 'main' java.util.ConcurrentModificationException
på java.util.HashMap $ HashIterator.nextEntry (okänd källa)
Låt oss nu gå vidare och titta på Fail Safe Iterator,
Felsäker Iterator
Till skillnad från Fail Fast iterators ger Fail Safe iterators inga undantag om samlingen ändras under iterationsprocessen. Detta beror på det faktum att de itererar på klon av samlingen, istället för den faktiska samlingen. De strukturella modifieringar som gjorts på den faktiska samlingen går obemärkt över dem.
Det bör dock noteras att det inte finns något sådant som en riktigt Fail Safe Iterator. Det vore lämpligt att beteckna det som svagt konsekvent. Detta betyder helt enkelt det om en samling modifieras under iterationsprocessen, det som Iteratorn ser är svagt garanterat. Detta beteende skiljer sig åt för olika samlingar och dokumenteras i Javadocs.
Exempel på Fail Safe Iterator:
public class FailSafeExample {public static void main (String [] args) {ConcurrentMap monthIndex = new ConcurrentHashMap () monthIndex.put ('1', 'January') monthIndex.put ('2', 'February') monthIndex.put ( '3', 'mars') Iterator iterator = monthIndex.keySet (). Iterator () medan (iterator.hasNext ()) {System.out.println (monthIndex.get (iterator.next ())) monthIndex.put ( '4', 'april')}}}Produktion:
- Januari
- Februari
- Mars
Slutligen i denna artikel skulle vi jämföra dessa iteratorer,
Skillnader: Fail Fast och Fail Safe Iterator
Nedan följer de väsentliga skillnaderna mellan de två iteratorerna:
skapa en länkad lista i c
| Parametrar | Fail Fast Iterator | Felsäker Iterator |
| Kasta ConcurrentModification Undantag | Ja, de kastar CocurrentModificationExcepti-on om en samling modifieras medan den går igenom den. | Nej, de kastar inget undantag om en samling modifieras medan den går igenom den. |
| Klona samlingen | Nej, de använder originalsamlingen för att korsa över elementen. | Ja, de använder kopian av originalsamlingen för att korsa. |
| Memory Overhead | Nej, de kräver inte extra minne. | Ja, de kräver extra minne för att klona samlingen. |
| Exempel | HashMap, Vector, ArrayList, HashSet | CopyOnWriteArrayList |
Dessa iteratorer är både unika och välbehövliga i Java: s mångsidiga språk. Trots att fail safe har en tröstande ring, visar sig fail-iteratorn vara robust.
Detta kommer till slutet av denna artikel. om du vill lära dig mer, kolla in av Edureka. Edurekas Java J2EE- och SOA-utbildning och certifieringskurs är utformad för att ge dig ett försprång till Java-programmering och träna dig för både kärn- och avancerade Java-koncept tillsammans med olika Java-ramverk som Hibernate & Spring.
Har du en fråga till oss? Vänligen nämna det i kommentarsektionen i denna 'Fail Fast vs Fail Safe' -blogg så återkommer vi så snart som möjligt.