Mislykkes hurtigt og fejlesikre Iteratorer i Java: Hvad er forskellen?

Denne artikel om 'Fail Fast And Fail Safe Iterators' hjælper dig med at sammenligne disse to Iteratorer i detaljer med relevante eksempler.

understøtter to typer iteratorer, den første er fail hurtigt og den anden er fail safe. Disse spiller en vigtig rolle, når det gælder undtagelseshåndtering i Java. I denne artikel om 'Fail Fast And Fail Safe Iterators' vil vi analysere funktionen af ​​de to iteratorer såvel som den væsentlige forskel mellem dem.



Følgende er de punkter, der skal diskuteres i denne artikel:



Før vi går ind i en detaljeret forklaring, kan vi gøre os bekendt med begrebet Concurrent Modification.

Samtidig ændring

Når en enkelt tråd (eller flere tråde) gentager sig over en samling, kan den ændre samlingens struktur enten ved at tilføje eller slette elementet i samlingen eller ved at opdatere elementets værdi på en bestemt position. Denne proces er kendt som samtidige ændringer.



Lad os hurtigt se på de to systemer, der vedrører ovenstående emne, inden vi går ind i detaljerne om det samme,

Fail Fast Sysetm:

Et system er mærket et fail hurtigt system, hvis det lukker ned umiddelbart efter forekomsten af ​​en fejl. Handlingerne afbrydes øjeblikkeligt, og fejlene eller fejlene afsløres.

Fejlsikkert system:

Et system er mærket som et fejlsikkert system, hvis de fortsætter med at fungere, selv efter at der er opstået en fejl eller en fejl. De afbryder ikke en operation og skjuler fejlene i stedet for at udsætte dem.



hvad er actionlistener i java

Iteratorer i java tillader os at krydse over samlingsobjekterne. Iteratorerne, der returneres af samlingen, fejler enten hurtigt eller fejler sikkert.

Fail Fast Iterator

Mislykkede hurtige iteratorer i Java tillader ikke enhver form for strukturændring af en samling, mens den gentages over den. Strukturændring inkluderer tilføjelse, fjernelse eller opdatering af ethvert element i samlingen, mens det gentages over det. Iteratoren kaster en ConcurrentModificationException, hvis en samling er strukturelt ændret under iterationsprocessen.

Det skal dog bemærkes, at hvis et element fjernes ved hjælp af iterators egen metode, dvs. metoden remove (), kastes der ingen undtagelse. Det er en helt sikker proces. sørg for at du har java installeret på dit system

Eksempel på Fail Fast Iterator:

import java.util.HashMap import 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 () mens (iterator.hasNext ()) {System.out .println (monthIndex.get (iterator.next ())) // tilføjelse af et element til Map // undtagelse kastes ved næste opkald // i næste () metode. monthIndex.put ('4', 'April')}}}

Produktion:

Undtagelse i tråden “main” java.util.ConcurrentModificationException

på java.util.HashMap $ HashIterator.nextEntry (Ukendt kilde)

Lad os nu gå videre og se på Fail Safe Iterator,

Fejlsikker Iterator

I modsætning til Fail Fast iterators kaster Fail Safe iterators ikke nogen undtagelser, hvis samlingen ændres under iterationsprocessen. Dette skyldes, at de gentager sig på samlingens klon i stedet for selve samlingen. De strukturelle ændringer, der er foretaget på selve samlingen, bliver ubemærket af dem.

Det skal dog bemærkes, at der ikke er noget, der hedder en virkelig fejlsikker Iterator. Det ville være hensigtsmæssigt at betegne det som svagt konsistent. Dette betyder simpelthen det hvis en samling ændres under iterationsprocessen, hvad Iteratoren ser er svagt garanteret. Denne adfærd adskiller sig for forskellige samlinger og er dokumenteret i Javadocs.

Eksempel på fejlsikker 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', 'marts') Iterator iterator = monthIndex.keySet (). Iterator () mens (iterator.hasNext ()) {System.out.println (monthIndex.get (iterator.next ())) monthIndex.put ( '4', 'april')}}}

Produktion:

  • januar
  • februar
  • marts

Endelig i denne artikel vil vi sammenligne disse iteratorer,

Forskelle: Fail Fast og Fail Safe Iterator

Nedenfor er de væsentlige forskelle mellem de to iteratorer:

Parametre Fail Fast Iterator Fejlsikker Iterator
Kast undtagelse med modifikation

Ja, de kaster CocurrentModificationExcepti-on, hvis en samling ændres, mens den gentages over den.

Nej, de kaster ikke nogen undtagelse, hvis en samling ændres, mens den gentages over den.

Klon samlingen

Nej, de bruger den originale samling til at krydse elementerne.

Ja, de bruger kopien af ​​den originale samling til at krydse.

Hukommelsesomkostninger

Nej, de kræver ikke ekstra hukommelse.

Ja, de har brug for ekstra hukommelse for at klone samlingen.

Eksempler

HashMap, Vector, ArrayList, HashSet

CopyOnWriteArrayList

Disse iteratorer er både unikke og meget nødvendige i java's alsidige sprog. Selvom fail safe har en trøstende ring, viser fail-iteratoren at være robust.

Dette bringer slutningen af ​​denne artikel. hvis du ønsker at lære mere, så tjek af Edureka. Edurekas Java J2EE- og SOA-uddannelses- og certificeringskursus er designet til at give dig et forspring i Java-programmering og træne dig til både kerne- og avancerede Java-koncepter sammen med forskellige Java-rammer som Hibernate & Spring.

Har du et spørgsmål til os? Nævn det i kommentarfeltet på denne 'Fail Fast vs Fail Safe' -blog, og vi vender tilbage til dig hurtigst muligt.