kétféle iterátort támogat, az egyik az egyik gyors, a második a biztonságos. Ezek létfontosságú szerepet játszanak a Java-ban történő kivételkezelés terén. Ebben a cikkben a ‘Fail Fast and Fail Safe Iterators’ témakörben a két iterátor működését, valamint a közöttük lévő lényeges különbséget fogjuk elemezni.
Az alábbiakban a cikkben tárgyalandó mutatók találhatók:
mik a példányváltozók a java-ban
- Egyidejű módosítások
- Nem sikerül a gyors iterátor
- Fail Safe Iterator
- Fail Fast vs Fail Safe Iterator
Mielőtt részletes magyarázatba kezdene, ismerkedjen meg a Párhuzamos módosítás fogalmával.
Egyidejű módosítás
Amikor egyetlen szál (vagy több szál) ismétlődik egy gyűjtemény felett, megváltoztathatja a gyűjtemény struktúráját, akár hozzáadva vagy törölve a gyűjtemény elemét, akár frissítve az elem értékét egy adott helyen. Ezt a folyamatot egyidejű módosításnak nevezik.
Vessünk egy gyors pillantást a fenti témát érintő két rendszerre, mielőtt rátérnénk ezek részleteire,
Fail Fail Sysetm:
A rendszert hibaelhárító rendszernek nevezik, ha hiba után azonnal leáll. A műveletek azonnal megszakadnak, és a hibák vagy a hibák ki vannak téve.
Biztonságos rendszer:
A rendszert hibabiztos rendszernek nevezik, ha hiba vagy hiba bekövetkezése után is tovább működnek. Nem szakítják meg a műveletet, és nem rejtik el a hibákat, hanem azokat.
A java itterátorai lehetővé teszik számunkra, hogy a Gyűjtemény objektumokon haladjunk. A Gyűjtemény által visszaadott iterátorok vagy gyorsan, vagy nem biztonságos jellegűek.
Nem sikerül a gyors iterátor
A Java gyors kudarcos iterátorai semmilyen strukturális módosítást nem engednek meg egy gyűjteménynek, miközben iterálnak rajta. A Strukturális módosítás magában foglalja a gyűjtemény bármely elemének hozzáadását, eltávolítását vagy frissítését, miközben az iterál. Az iterátor dob egy ConcurrentModificationException-t, ha egy gyűjtemény szerkezetileg módosul az iteráció folyamata során.
Meg kell azonban jegyezni, hogy ha egy elemet az iterátorok saját módszerével, azaz az remove () módszerrel távolítanak el, akkor nem vetnek ki kivételt. Ez egy teljesen biztonságos folyamat. győződjön meg róla, hogy van java telepítve a rendszerén
Példa a Fail Fast Iteratorra:
import java.util.HashMap import java.util.Iterator import java.util.Map nyilvános osztály FailFastExample {public static void main (String [] args) {Map monthIndex = new HashMap () monthIndex.put ('1', 'január ') monthIndex.put (' 2 ',' February ') monthIndex.put (' 3 ',' March ') Iterator iterator = monthIndex.keySet (). iterator () while (iterator.hasNext ()) {System.out .println (monthIndex.get (iterator.next ())) // elem hozzáadása a Map // kivételhez a következő () metódus következő hívásakor // kivetésre kerül. monthIndex.put ('4', 'április')}}}Kimenet:
Kivétel a „main” szálban java.util.ConcurrentModificationException
itt: java.util.HashMap $ HashIterator.nextEntry (Ismeretlen forrás)
Most menjünk előre, és vessünk egy pillantást a Fail Safe Iteratorra,
Fail Safe Iterator
A Fail Fast iterátorokkal ellentétben a Fail Safe iterátorok nem vetnek ki kivételeket, ha a gyűjtemény módosul az iteráció folyamata során. Ez annak köszönhető, hogy a tényleges gyűjtemény helyett a gyűjtemény klónján iterálnak. A tényleges gyűjteményen elvégzett szerkezeti módosításokat észrevétlenül hagyják.
Azt azonban észre kell venni, hogy nincs olyan, hogy valóban Fail Safe Iterator. Helyénvaló lenne gyengén következetesnek nevezni. Ez egyszerűen azt jelenti ha egy gyűjtemény az iteráció folyamata alatt módosul, amit az Iterator lát, gyengén garantált. Ez a viselkedés a különböző gyűjteményeknél eltér, és a Javadocs dokumentálja.
Példa a Fail Safe Iteratorra:
public class FailSafeExample {public static void main (String [] args) {ConcurrentMap monthIndex = new ConcurrentHashMap () monthIndex.put ('1', 'January') monthIndex.put ('2', 'February') monthIndex.put ( '3', 'március') Iterator iterator = monthIndex.keySet (). Iterator () while (iterator.hasNext ()) {System.out.println (monthIndex.get (iterator.next ())) monthIndex.put ( '4', 'április')}}}Kimenet:
hogyan kell most használni a szolgáltatást
- január
- február
- március
Végül ebben a cikkben összehasonlítanánk ezeket az iterátorokat,
Különbségek: Fail Fail Fast and Fail Safe Iterator
Az alábbiakban bemutatjuk a két iterátor közötti lényeges különbségeket:
| Paraméterek | Nem sikerül a gyors iterátor | Fail Safe Iterator |
| Dobja a ConcurrentModification Kivételt | Igen, a CocurrentModificationExcepti-on dobják, ha egy gyűjteményt módosítanak, miközben iterálnak rajta. | Nem, nem vetnek ki kivételt, ha egy gyűjteményt módosítanak, miközben iterálnak rajta. |
| Klónozza a gyűjteményt | Nem, az eredeti gyűjteményen keresztül haladnak az elemek felett. java mikor kell ezt használni | Igen, az eredeti gyűjtemény másolatát használják a bejáráshoz. |
| Memória rezsi | Nem, nem igényelnek extra memóriát. | Igen, további memóriára van szükségük a gyűjtemény klónozásához. |
| Példák | HashMap, Vector, ArrayList, HashSet | CopyOnWriteArrayList |
Ezek az iterátorok egyedülállóak és nagyon szükségesek a java sokoldalú nyelvén. Noha a hibabiztonságnak van egy megnyugtató gyűrűje, a hibamentes iterátor robusztusnak bizonyul.
Ezzel a cikk végére kerül. Ha többet szeretne megtudni, akkor nézze meg a írta Edureka. Az Edureka Java J2EE és SOA képzési és tanúsítási tanfolyamát úgy tervezték, hogy előrelépést nyújtson a Java programozásban, és betanítson mind az alapvető, mind a fejlett Java koncepciókra, valamint a különböző Java keretrendszerekkel, például a Hibernate & Spring.
Van egy kérdésünk? Kérjük, említse meg a „Fail Fast vs Fail Safe” blog megjegyzés rovatában, és a lehető leghamarabb kapcsolatba lépünk Önnel.