Ipakilala ka ng artikulong ito sa isang konsepto na tinawag bilang Kasabay na Hash Map In at sundin ito sa isang praktikal na pagpapakita. Ang mga sumusunod na pahiwatig ay sasakupin sa artikulong ito,
- Paano gumagana ang Panloob naHashMap sa loob?
- Bakit ibang Mapa?
- Paano ito naiiba?
- Pagkakaiba sa pagitan ng ConcurrentHashMap at HashMap
- Mga pitfalls
Nagpapatuloy sa artikulong ito sa Kasabay na Hash Map sa Java
Paano gumagana ang Panloob naHashMap sa loob?
Mula sa Java 5 pataas ang Kasabay naHashMap ay ipinakilala bilang isang kahalili para sa HashTable. Maaari rin kaming makakuha ng isang naka-synchronize na mapa gamit ang paraan ng utility class na tinatawag na synchronizedMap () ngunit mayroong isang sagabal sa pamamaraang ito na napakahirap na pagganap dahil ang isang solong thread lamang ang maaaring ma-access ito sa isang pagkakataon. Kaya't tinutugunan ng ConcurrentHashMap ang mga isyung ito.
Nagpapatuloy sa artikulong ito sa Kasabay na Hash Map sa Java
Bakit ibang Mapa?
Kahit na mayroon na tayong HashMap, HashTable kung ano ang kailangan ng ConcurrentHashMap, ito ay dahil nagbibigay ito ng mas mahusay na pagganap sa parehong oras na ito ay ligtas sa thread.
Nagpapatuloy sa artikulong ito sa Kasabay na Hash Map sa Java
Paano ito naiiba?
Batay din ito sa pag-hash ngunit ang pagganap nito ay napabuti ng diskarte sa pag-lock nito. Hindi tulad ng HashTable o Synchronized HashMap hindi ito naglalapat ng parehong lock sa bawat pamamaraan na gumagamit ito ng isang hiwalay na lock para sa bawat pamamaraan, Gumagamit ito ng muling entrant lock para sa hangaring ito. Katulad ng HashMap, ang ConcurrentHashMap ay may 16 na timba ibig sabihin, upang likhain ang ConcurrentHashMap na may higit sa 16 na balde mayroon itong magkakaibang mga konstruktor.
Bago makipag-usap nang detalyado suriin natin ang ilang mga konsepto sa ibaba:
KasabayHashMap: Pinapayagan ng map na ito ang kasabay na pag-access ng thread. Ang bahagi lamang ng mapa na tinawag na segment, kung saan ang napapailalim na istraktura ng data ay nakakulong habang nagdaragdag o nag-a-update ng mapa. Pinapayagan nito ang kasabay na pag-access ng thread na basahin ang data nang walang pagla-lock. Ipinakilala ito upang mapabuti ang pagganap.
- Antas ng Kasabay: Ito ay isang numero na kung saan ay isang tinantyang bilang ng mga kasabay na pag-update ng mga thread.
- Load-Factor: Ito ay isang halaga na ginagamit upang makontrol ang kadahilanan ng pagbabago ng laki.
- Paunang Kapasidad: Ito ay isang pag-aari na lumilikha ng isang Mapa na may sukat na ibinigay.
Tingnan natin sa ibaba ang diagram at subukang unawain kung paano gumagana ang ConcurrentHashMap.
Kaya sa nasa itaas na diagram, mayroon kaming 16 na kandado kung saan ang lock lamang ng isang bahagi ng mapa na kinakailangan upang ang iba pang mga pamamaraan ay maaaring ma-access ng iba't ibang mga thread kaya mapabuti ang pagganap.
Katulad ng HashMap, gumagana ang ConcurrentHashMap sa isang katulad na paraan na naglalaman ito ng 16 na mga segment bilang default at nag-iimbak ng elemento sa pamamagitan ng pag-hash kung ang mga elemento ay may parehong hash na nakaimbak sa parehong segment tulad ng ipinakita sa diagram sa itaas sa tulong ng naka-link na listahan.
Nagpapatuloy sa artikulong ito sa Kasabay na Hash Map sa Java
Pagkakaiba sa pagitan ng ConcurrentHashMap at HashMap
Ang HashMap ay kabilang sa Mga Koleksyon habang ang ConcurrentHashMap ay kabilang sa Mga Kasabay na Koleksyon subalit maraming iba pang mga pagkakaiba sa pagitan nila.
ano ang pagkakaiba sa pagitan ng xml at html
- Ang KasabayangHashMap ayThread-safe ibig sabihinnaka-synchronize ngunit ang HashMap ay hindi na-synchronize.
- Ang ConcurrentHashMap ay mababa sa pagganap sapagkat ito ay naka-synchronize dahil kung minsan ang mga thread ay kailangang maghintay ngunit ang HashMap ay mataas sa pagganap dahil hindi ito nasabay at ang anumang mga thread ay maaaring ma-access ito nang sabay-sabay.
Makakakuha kami ng ConcurrentModificationException kung ang dalawang mga thread ay sabay na sumusubok na baguhin o magdagdag ng mga nilalaman ng Bagay. Gayunpaman, sa kaso ng ConcurrentHashMap hindi kami makakakuha ng anumang pagbubukod habang ginaganap ang parehong operasyon.
Pinapayagan ang mga null na halaga para sa susi at mga halaga sa HashMap gayunpaman, hindi pinapayagan ng ConcurrentHashMap ang mga null na halaga para sa key at halagang sinubukan nitong magdagdag ng null na halaga ay magkakaroon kami ng pagbubukod i.e NullPointerException.
Ang HashMap ay ipinakilala sa JDK 1.2 samantalang ang ConcurrentHashMap ay ipinakilala sa JDK 1.5.
Tulad ng nakita natin nang mas maaga para sa mas mahusay na pagganap, binubuo ito ng isang hanay ng mga node bilang mga bucket ng talahanayan na mga segment ng talahanayan bago Java 8 .
Ang mga timba ay tinatamad na pinasimulan kapag isinagawa ang unang pagpapasok. Ang bawat balde ay maaaring mai-lock nang nakapag-iisa sa pamamagitan ng pag-lock ng unang node ng bucket na basahin din ang mga operasyon ay huwag i-block.
Kumpara sa HashMap, KasabayHashMap nagbibigay ng dagdag concurrencyLevel argumento upang makontrol ang bilang ng mga tinantyang mga thread na gagamitin.
Mga tagapagbuo:
KasabayHashMap m = bagong KasabayHashMap ()
Ang isang bagong walang laman na mapa ay nilikha na may isang default na paunang kapasidad na 16, load factor na 0.75 at antas ng pagsabay sa 16.
ConcurrentHashMap m = bagong ConcurrentHashMap (int initialCapacity)
Ang isang bagong walang laman na mapa ay nilikha na may isang tinukoy na paunang kakayahan, load factor na 0.75 at antas ng pagsabay sa 16.ConcurrentHashMap m = bagong ConcurrentHashMap (int initialCapacity, float loadFactor)
Ang isang bagong walang laman na mapa ay nilikha na may isang tinukoy na paunang kapasidad at load factor na may antas ng pagsabay sa 16.
ConcurrentHashMap m = bagong ConcurrentHashMap (int initialCapacity, float loadFactor, int concurrencyLevel)
Ang isang bagong walang laman na mapa ay nilikha na may isang tinukoy na paunang kapasidad, load factor at antas ng pagsabay.ConcurrentHashMap m = bagong ConcurrentHashMap (Map m)
Lumilikha ng bagong ConcurrentHashMap mula sa ibinigay na mapa.
Ang iba pang dalawang mga argumento: ang unangKapasidad at loadFactor ay nagtrabaho halos pareho sa HashMap.
Ang ConcurrentMap ay pare-pareho ang memorya sa mga pagpapatakbo ng key / halaga sa isang multi-threaded na kapaligiran.
Nagpapatuloy sa artikulong ito sa Kasabay na Hash Map sa Java
Mga pitfalls
Habang kinukuha ang mga bagay na ConcurrentHashMap ay hindi naka-block at maaaring mag-overlap sa mga pagpapatakbo ng pag-update, sa gayon para sa mas mahusay na pagganap kinukuha lamang nila ang pinakabagong nakumpleto na mga operasyon sa pag-update.
Ang mga resulta ng mga pinagsamang pamamaraan ng katayuan kabilang ang laki, isEmpty, at naglalaman ngValue ay karaniwang kapaki-pakinabang lamang kapag ang isang mapa ay hindi sumasailalim ng mga kasabay na pag-update sa iba pang mga thread.
Kung ang mga kasabay na pag-update ay kinokontrol nang maayos ang mga pamamaraang katayuan na ito ay maaaring maging maaasahan.
Bagaman ang mga pamamaraang ito ay hindi ginagarantiyahan sa real-time.
Ang default na kapasidad ng talahanayan ay 16 subalit maaari naming baguhin ito gamit ang antas ng pagsabay.
public ConcurrentHashMap (int initialCapacity, float loadFactor, int concurrencyLevel) {// ... if (initialCapacityKung ang mga key key ay kinakailangan upang maayos ayon sa pagkakasunud-sunod maaari naming gamitin ang ConcurrentSkipListMap.
Ngayon pagkatapos maipatupad ang nasa itaas na programa na maunawaan mo ang Kasabay na Hash Map sa Java. Sa gayon ay natapos na kami sa artikulong ito sa Kung nais mong matuto nang higit pa, tingnan ang , isang pinagkakatiwalaang kumpanya sa online na pag-aaral. Ang kurso sa pagsasanay at sertipikasyon ng Java J2EE at SOA ng Edureka ay idinisenyo upang 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 artikulong ito at babalikan ka namin sa lalong madaling panahon.