Ang mga program na multi-thread ang maaaring regular na magkaroon ng isang pangyayari kung saan maramihang pagtatangka upang makarating sa parehong mapagkukunan na gumagawa ng mapanlinlang at nakakagulat na mga kinalabasan. Maaari itong malutas sa pamamagitan ng paggamit ng pagsabay sa Java. Ang isang solong natukoy lamang na thread ay maaaring makapunta sa mapagkukunan sa isang naibigay na layunin ng oras. Tutulungan ka ng artikulong ito na maging pamilyar sa diskarte sa pag-synchronize.
Tatalakayin ko ang mga paksa sa ganitong pagkakasunud-sunod:
- Bakit ginagamit ang Sinkronisasyon sa Java?
- Mga uri ng Pagsasabay
- Mga kandado sa Java
- Multi-threading nang walang Sinkronisasyon
- Multi-threading kasama ang Pag-synchronize
- Naisabay na Keyword
- Pagkakaiba sa pagitan ng naka-synchronize na keyword at na-synchronize na bloke
Magsimula na tayo!
Bakit ginagamit ang Sinkronisasyon sa Java?
Kung nagsisimula ka sa hindi bababa sa dalawang mga thread sa loob ng isang programa, maaaring mayroong isang pagkakataon kapag ang maraming mga thread ay nagtatangka upang makarating sa parehong mapagkukunan. Maaari pa itong lumikha ng isang hindi inaasahang kinalabasan dahil sa mga isyu sa pagsabay.
Syntax :
sinabay (objectidentifier) {// I-access ang mga nakabahaging variable at iba pang nakabahaging mapagkukunan}Halimbawa, tangkang magsulat sa loob ng isang katumbas na file. Maaari nitong masira ang data dahil ang isa sa mga thread ay maaaring ma-override ang data o kapag binuksan ng isang thread angparehong file nang sabay, ang isa pang thread ay maaaring magsara ng parehong file.May pangangailangan na i-synchronize ang pagkilos ng maraming mga thread. Maaari itong ipatupad gamit ang isang konsepto na tinatawag M mga onitor .
- Bawat isa ay naiugnay sa isang monitor, kung saan ang isang thread ay maaaring i-lock o i-unlock.
- Tanging ang isang thread nang paisa-isa ay maaaring magkaroon ng lock sa isang monitor.
- Java ang wika ng programa ay nagbibigay ng isang napaka madaling gamiting paraan ng paglikha ng mga thread at pagsabay sa kanilang gawain sa pamamagitan ng paggamit ng Sinabay mga bloke.
- Pinapanatili rin nito ang mga ibinahaging mapagkukunan sa loob ng partikular na bloke na ito.
Ang mga naka-sync na bloke sa Java ay minarkahan ng Sinabay keyword. Ang pag-block sa Java ay na-synchronize sa ilang mga object.Ang lahat ng mga bloke na na-synchronize sa parehong bagay ay maaari lamang magkaroon ng isang thread na isinasagawa sa loob ng mga ito nang paisa-isa. Ang lahat ng iba pang mga thread na nagtatangkang ipasok ang naka-synchronize na bloke ay hinarangan hanggang sa ang thread sa loob ng naka-synchronize na bloke ay lumabas sa bloke.
Mga uri ng Pagsasabay
Mayroong karaniwang dalawang uri ng pag-synchronize na magagamit. Sila ay:
- Proseso ng Pag-synchronize: Ang sabay-sabay na pagpapatupad ng maraming mga thread o proseso upang maabot ang isang estado na nais nilang gawin sa isang tiyak na pagkakasunud-sunod ng mga pagkilos.
- Pagsabay sa Thread: Sa mga oras na higit sa isang threadSinusubukan upang ma-access ang isang nakabahaging mapagkukunan, kailangan mong tiyakin na ang mapagkukunan ay gagamitin ng isang thread lamang saisang oras
Huwag nating pansinin ang mga detalye ng mga ganitong uri at subukang unawain kung ano ang mga naka-lock .
Mga kandado sa Java
Tulad ng nabanggit ko kanina, ang Pag-synchronize ay binuo sa paligid ng isang panloob na nilalang na kilala bilang magkandado o monitor . Ang bawat at bawat bagay ay may isang lock na nauugnay dito. Kaya't ang isang thread na nangangailangan ng pare-parehong pag-access sa mga patlang ng isang bagay ay kailangang kumuha ng lock ng object bago i-access ang mga ito, at pagkatapos ay bitawan ang lock kapag tapos na ang trabaho.
Mula sa Java 5, ang package java.util.concurrent.locks ay naglalaman ng maraming mga pagpapatupad ng lock.
Ganito ang hitsura ng isang lock:
pagsubok na hinimok ng data sa siliniyum
public class Lock {private boolean isLocked = false public synchized void lock () throws InterruptException {habang (isLocked) {wait ()} isLocked = true} public synchronized void unlock () {isLocked = false notify ()}}Ang lock () na paraan ay nakakandado ang Lock instance upang ang lahat ng mga thread na tumatawag sa lock () ay naharang hanggang i-unlock () ang naisakatuparan.
Multi-threading nang walang Sinkronisasyon
Narito ang isang simpleng halimbawa na naglilimbag ng counter na halaga sa isang pagkakasunud-sunod at sa tuwing tatakbo namin ito, gumagawa ito ng ibang resulta batay sa kakayahang magamit ng CPU sa isang thread. Tingnan mo ito!
klase Multithread {public void printCount () {try {for (int i = 5 i<0 i--) { System.out.println('Counter --- ' + i ) } } catch (Exception e) { System.out.println('Thread interrupted.') } } } class Thread extends Multithread { private Thread t private String threadName Multithread MT Thread( String name, Multithread mt) { threadName = name MT= mt } public void run() { MT.printCount() System.out.println('Thread ' + threadName + ' exiting.') } public void start () { System.out.println('Starting ' + threadName ) if (t == null) { t = new Thread (this, threadName) t.start () } } } public class TestThread { public static void main(String args[]) { Multithread MT = new Multithread() Thread t = new Thread( 'Thread - 1 ', MT) Thread t1 = new Thread( 'Thread - 2 ', MT) t.start() t1.start() // wait for threads to end try { t.join() t1.join() } catch ( Exception e) { System.out.println('Interrupted') } } }Ang mga resulta sa itaas ng programa sa ito:
Multi-threading kasama ang Pag-synchronize
kung paano i-convert ang isang doble sa isang int
Ito ang kaparehong halimbawa tulad ng nasa itaas ngunit inililimbag nito ang counter na halaga sa pagkakasunud-sunod. Sa tuwing tatakbo namin ito, gumagawa ito ng parehong resulta.
class Multithread {public void printCount () {try {for (int i = 5 i> 0 i--) {System.out.println ('Counter ---' + i)}} catch (Exception e) {System. out.println ('Nagambala ang Thread.')}}} Ang klase na Thread ay nagpapalawak ng Multithread {pribadong Thread t pribadong String threadName Multithread MT Thread (String name, Multithread mt) {threadName = name MT = mt} public void run () {synchronised ( MT) {MT.printCount ()} System.out.println ('Thread' + threadName + 'exiting.')} Pampublikong walang bisa na pagsisimula () {System.out.println ('Simula' + threadName) kung (t == null) {t = bagong Thread (ito, threadName) t.start ()}}} pampublikong klase TestThread {public static void main (String args []) {Multithread MT = new Multithread () Thread T = new Thread ('Thread - 1 ', MT) Thread T1 = bagong Thread (' Thread - 2 ', MT) T.start () T1.start () // maghintay para sa mga thread na matapos na subukan ang {T.join () T1.join ()} catch (Exception e) {System.out.println ('Nagambala')}}}Ang output ay nakalarawan sa ibaba:
Naisabay na Keyword
sinabay na keyword nagmamarka ng isang bloke o isang pamamaraan na isang kritikal na seksyon. Ang isang kritikal na seksyon ay kung saan ang isang thread lamang ang naisakatuparan nang paisa-isa, at ang thread ang humahawak ng kandado para sa naisabay na seksyon. Ito sinabay tumutulong ang keyword sa pagsusulat kasabay mga bahagi ng anumang aplikasyon. Pinoprotektahan nito ang mga nakabahaging mapagkukunan sa loob ng bloke.
Maaaring gamitin ang naka-synchronize na keyword sa:
Talakayin natin ang code block.
Na-synchronize na Keyword: Isang bloke ng code
Syntax
Ang pangkalahatang syntax para sa pagsulat ng isang naka-synchronize na bloke ay:
naka-synchronize (lockObject) {// naka-synchronize na mga pahayag}Kapag nais ng isang thread na ipatupad ang mga naka-synchronize na pahayag sa loob ng bloke, dapat itong makuha ang lock sa monitor ng lockObject. Isang thread lamang ang makakakuha ng monitor ng isang lock object nang paisa-isa. Kaya't ang lahat ng iba pang mga thread ay dapat maghintay hanggang ang kasalukuyang nagpapatupad ng thread ay makakakuha ng lock at tapusin ang pagpapatupad nito.
Sa ganitong paraan, ang sinabay ginagarantiyahan ng keyword na isang thread lamang ang ipapatupad ang mga naka-synchronize na pahayag ng block nang paisa-isa, at sa gayon ay pinipigilan ang maraming mga thread mula sa sirain ang nakabahaging data na naroroon sa loob ng bloke.
Tandaan :
- Kung ang isang thread ay pinatulog (gamit
matulog ()pamamaraan) pagkatapos ay hindi nito pinakawalan ang lock. Sa oras ng pagtulog na ito, walang thread na ipapatupad ang mga na-synchronize na pahayag ng block. - Itatapon ang pagsasabay sa Java NullPointerException kung ang lock object na ginamit sa ‘ sinabay (lock) ' ay walang bisa.
Ngayon, talakayin natin ang pamamaraan.
Naisabay na Keyword: Isang paraan
Syntax
Ang pangkalahatang syntax para sa pagsulat a kasabay na pamamaraan ay:
naka-synchronize na pamamaraan (mga parameter) {// naka-synchronize na code}Dito lockObject ay isang sanggunian lamang sa isang bagay na ang lock ay naiugnay sa monitor na kumakatawan sa mga naka-synck na pahayag.
Katulad ng na-synchronize na bloke, dapat na makuha ng isang thread ang lock sa nakakonektang monitor na bagay na may kasamang pamamaraan. Sa kaso ng naka-synchronize na pamamaraan, ang lock object ay:
- Bagay na ‘.class’ - kung ang ibinigay na pamamaraan ay static .
- Object na ‘to - kung ang pamamaraan ay hindi static . Ang 'ito' ay ang sanggunian sa kasalukuyang bagay kung saan ipinatawag ang naka-synchronize na pamamaraan.
Ang naka-synchronize na keyword na Java ay muling pumasok sa kalikasan. Nangangahulugan ito kung ang isang naka-synchronize na pamamaraan ay tumatawag sa isa pang naka-synchronize na pamamaraan na nangangailangan ng parehong lock, kung gayon ang kasalukuyang thread na may hawak na lock ay maaaring pumasok sa pamamaraang iyon nang hindi nakuha ang lock.
Tayo ay magpatuloy sa pangwakas na paksa ng artikulong ito at ituro ang mga pangunahing pagkakaiba sa pagitan ng naka-synchronize na keyword at bloke ng pag-synchronize.
Pagkakaiba sa pagitan ng naka-synchronize na keyword at na-synchronize na bloke
- Kapag gumamit ka ng nasabay na keyword sa isang paraan , nakakakuha ito ng isang lock sa bagay para sa buong pamamaraan. Nangangahulugan ito na walang ibang thread na maaaring gumamit ng anumang naka-synchronize na pamamaraan hanggang sa natapos ang pagpapatupad ng kasalukuyang thread na tinawag.
- Sinabay harangan nakakakuha ng isang lock sa object sa pagitan lamang ng mga panaklong pagkatapos na tinukoy ang naka-synchronize na keyword. Nangangahulugan ito na walang ibang thread na maaaring makakuha ng isang lock sa naka-lock na object hanggang sa lumabas ang block. Ngunit ang iba pang mga thread ay maa-access ang natitirang code na naroroon sa pamamaraan.
Dinadala nito sa amin ang katapusan ng artikulong ito kung saan tinalakay namin kung paano eksaktong gumagana ang Pag-synchronize sa Java. Inaasahan mong malinaw ka sa lahat ng naibahagi sa iyo sa tutorial na ito.
pagbabago ng paghahanap sa halimbawa ng informatica
Suriin ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online na may isang network na higit sa 250,000 nasiyahan na mga nag-aaral na kumalat sa buong mundo. Narito kami upang matulungan ka sa bawat hakbang sa iyong paglalakbay, para sa pagiging isang bukod sa mga katanungang ito sa panayam sa java, nakakakuha kami ng isang kurikulum na idinisenyo para sa mga mag-aaral at propesyonal na nais na maging isang Java Developer.
May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng 'Pagsasabay sa Java ' artikulo at babalikan ka namin sa lalong madaling panahon.