Nabigo Nang Mabilis At Nabigo ang Mga Ligtas na Iterator Sa Java: Ano ang Pagkakaiba?

suportahan ang dalawang uri ng mga iterator, ang una ay mabibigo nang mabilis at ang pangalawa ay mabigo nang ligtas. Malaki ang papel na ginagampanan ng mga ito pagdating sa pagbubukod ng pagbubukod sa Java. Sa artikulong ito sa 'Fail Fast And Fail Safe Iterators', susuriin namin ang pagtatrabaho ng dalawang mga iterator pati na rin ang mahahalagang pagkakaiba sa pagitan nila.

Ang mga sumusunod ay ang mga payo na tatalakayin sa artikulong ito:

• Mga Kasabay na Pagbabago
• Nabigo ang Mabilis na Iterator
• Nabigo ang Safe Iterator
• Nabigo ang Mabilis vs mabibigo ang Safe Iterator

Bago makakuha ng isang detalyadong paliwanag, hinahayaan na pamilyar ang ating sarili sa konsepto ng Kasabay na Pagbabago.

Kasabay na Pagbabago

Kapag ang isang solong thread (o maraming mga thread), umuulit sa isang koleksyon, maaari nitong baguhin ang istraktura ng koleksyon, alinman sa pamamagitan ng pagdaragdag o pagtanggal ng elemento sa koleksyon, o sa pamamagitan ng pag-update ng halaga ng elemento sa isang partikular na posisyon. Ang prosesong ito ay kilala bilang kasabay na pagbabago.

Mabilis na tingnan natin ang dalawang System na may kinalaman sa itaas na paksa, bago masuri ang mga detalye ng pareho,

Nabigo ang Mabilis na Sysetm:

Ang isang system ay may label na isang mabibigong mabilis na system, kung ito ay agad na nakasara pagkatapos ng paglitaw ng isang error. Agad na pinalaglag ang mga operasyon at ang mga pagkabigo o ang mga error ay nakalantad.

Nabigo ang Safe System:

Ang isang system ay may label na isang nabigong ligtas na system, kung magpapatuloy silang gumana kahit na may naganap na pagkakamali o isang error. Hindi nila pinalaglag ang isang operasyon at itinatago ang mga error sa halip na ilantad ang mga ito.

Pinapayagan kami ng mga Iterator sa java na dumaan sa mga object ng Koleksyon. Ang mga iterator na ibinalik ng Koleksyon ay maaaring mabigo nang mabilis o mabigo na ligtas sa likas na katangian.

Nabigo ang Mabilis na Iterator

Nabigo ang mabilis na mga iterator sa Java na hindi pinapayagan ang anumang uri ng pagbabago sa istruktura sa isang koleksyon habang paulit-ulit dito. Kasama sa Pagbabago ng Struktural ang pagdaragdag, pag-aalis o pag-update ng anumang elemento sa koleksyon habang inuulit ito. Ang iterator ay nagtatapon ng isang Kasabay na PagbabagoException, kung ang isang koleksyon ay nabago sa istraktura sa panahon ng proseso ng pag-ulit.

Gayunpaman, dapat pansinin na kung ang isang item ay tinanggal gamit ang sariling mga iterator na pamamaraan ibig sabihin ang alisin () na pamamaraan, walang pagbubukod na itinapon. Ito ay isang ganap na ligtas na proseso. siguraduhin na mayroon ka naka-install na java sa iyong system

Halimbawa ng Fail Fast Iterator:

import java.util.HashMap import java.util.Iterator import java.util.Map pampublikong klase FailFastExample {public static void main (String [] args) {Map monthIndex = new HashMap () monthIndex.put ('1', 'Enero ') monthIndex.put (' 2 ',' Pebrero ') monthIndex.put (' 3 ',' March ') Iterator iterator = monthIndex.keySet (). iterator () habang (iterator.hasNext ()) {System.out .println (monthIndex.get (iterator.next ())) // pagdaragdag ng isang elemento sa Map // na pagbubukod ay itatapon sa susunod na paraan ng pagtawag // ng susunod (). monthIndex.put ('4', 'April')}}}

Output:

Pagbubukod sa thread na 'pangunahing' java.util.ConcurrentModificationException

sa java.util.HashMap $ HashIterator.nextEntry (Hindi Kilalang Pinagmulan)

Ngayon ay magpatuloy tayo at tingnan ang Fail Safe Iterator,

Nabigo ang Safe Iterator

Hindi tulad ng Fail Fast iterators, ang Fail Safe iterators ay hindi nagtatapon ng anumang mga pagbubukod kung ang koleksyon ay nabago sa panahon ng proseso ng pag-ulit. Ito ay dahil sa ang katunayan na umuulit sila sa clone ng koleksyon, sa halip na ang aktwal na koleksyon. Ang mga pagbabago sa istruktura na tapos sa aktwal na koleksyon ay hindi napansin ng mga ito.

Gayunpaman, dapat pansinin na walang bagay tulad ng isang tunay na Fail Safe Iterator. Angkop na termin ito bilang Mahina-Pare-pareho. Nangangahulugan lamang ito na kung ang isang Koleksyon ay binago sa panahon ng proseso ng pag-ulit, kung ano ang nakikita ng Iterator ay mahinang ginagarantiyahan. Ang pag-uugali na ito ay naiiba para sa iba't ibang mga koleksyon at naitala sa Javadoc.

Halimbawa ng Fail Safe Iterator:

publikong klase FailSafeExample {public static void main (String [] args) {ConcurrentMap monthIndex = new ConcurrentHashMap () monthIndex.put ('1', 'Enero') monthIndex.put ('2', 'Pebrero') monthIndex.put ( '3', 'March') Iterator iterator = monthIndex.keySet (). Iterator () habang (iterator.hasNext ()) {System.out.println (monthIndex.get (iterator.next ())) monthIndex.put [ '4', 'Abril')}}}

Output:

• Enero
• Pebrero
• Marso

Panghuli sa artikulong ito ihinahambing namin ang mga iterator na ito,

Mga Pagkakaiba: Nabigo nang Mabilis At Nabigo ang Ligtas na Iterator

Ibinigay sa ibaba ang mahahalagang pagkakaiba sa pagitan ng dalawang iterator:

Ang mga iterator na ito ay kapwa natatangi at higit na kinakailangan sa maraming nalalaman na wika ng java. Bagaman ang fail safe ay mayroong isang umaaliw na singsing dito, ang nabigong mabilis na iterator ay nagpapatunay na maging matatag.

Dinadala nito ang pagtatapos ng artikulong ito. kung sakaling nais mong matuto nang higit pa pagkatapos suriin ang ni Edureka. Ang kurso sa pagsasanay at sertipikasyon ng Java J2EE at SOA ng Edureka ay idinisenyo upang bigyan ka ng isang panimula sa pagprograma ng Java at sanayin ka para sa parehong core at advanced na mga konsepto ng Java kasama ang iba't ibang mga balangkas ng Java tulad ng Hibernate & Spring.

May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng blog na 'Nabigong Mabilis kumpara sa Mabigong Ligtas' at babalikan ka namin sa lalong madaling panahon.