Multitrådede programmer kan ofte komme til en situation, hvor flere tråde forsøger at få adgang til de samme ressourcer og til sidst producerer fejlagtige og uforudsete resultater.
Hvorfor bruge Java-synkronisering?
Java-synkronisering bruges til at sikre ved en eller anden synkroniseringsmetode, at kun én tråd kan få adgang til ressourcen på et givet tidspunkt.
ups
Java-synkroniserede blokke
Java giver en måde at skabe tråde og synkronisere deres opgaver ved hjælp af synkroniserede blokke.
En synkroniseret blok i Java er synkroniseret på et eller andet objekt. Alle synkroniserede blokke synkroniseres på det samme objekt og kan kun have én tråd udført inde i dem ad gangen. Alle andre tråde, der forsøger at komme ind i den synkroniserede blok, blokeres, indtil tråden inde i den synkroniserede blok forlader blokken.
Bemærk: Synkroniserede blokke i Java er markeret med det synkroniserede nøgleord.
Generel form for synkroniseret blok
// Only one thread can execute at a time. // sync_object is a reference to an object // whose lock associates with the monitor . // The code is said to be synchronized on // the monitor object synchronized(sync_object) { // Access shared variables and other // shared resources }> Denne synkronisering er implementeret i Java med et koncept kaldet skærme eller låse. Kun én tråd kan eje en skærm på et givet tidspunkt. Når en tråd får en lås, siges den at være kommet ind i monitoren. Alle andre tråde, der forsøger at komme ind i den låste skærm, vil blive suspenderet, indtil den første tråd forlader skærmen.
Typer af synkronisering
Der er to synkroniseringer i Java nævnt nedenfor:
- Processynkronisering
- Trådsynkronisering
1. Processynkronisering i Java
Processynkronisering er en teknik, der bruges til at koordinere udførelsen af flere processer. Det sikrer, at de fælles ressourcer er sikre og i orden.
2. Trådsynkronisering i Java
Trådsynkronisering bruges til at koordinere og bestille afviklingen af trådene i et flertrådet program. Der er to typer trådsynkronisering, der er nævnt nedenfor:
- Gensidig eksklusiv
- Samarbejde (Inter-thread kommunikation i Java)
Gensidig eksklusiv
Mutual Exclusive hjælper med at forhindre tråde i at forstyrre hinanden, mens de deler data. Der er tre typer af Mutual Exclusive nævnt nedenfor:
- Synkroniseret metode.
- Synkroniseret blok.
- Statisk synkronisering.
Eksempel på synkronisering
Nedenfor er implementeringen af Java Synchronization:
Java
gentage et kort i java
// A Java program to demonstrate working of> // synchronized.> import> java.io.*;> import> java.util.*;> // A Class used to send a message> class> Sender {> >public> void> send(String msg)> >{> >System.out.println(>'Sending '> + msg);> >try> {> >Thread.sleep(>1000>);> >}> >catch> (Exception e) {> >System.out.println(>'Thread interrupted.'>);> >}> >System.out.println(>'
'> + msg +>'Sent'>);> >}> }> // Class for send a message using Threads> class> ThreadedSend>extends> Thread {> >private> String msg;> >Sender sender;> >// Receives a message object and a string> >// message to be sent> >ThreadedSend(String m, Sender obj)> >{> >msg = m;> >sender = obj;> >}> >public> void> run()> >{> >// Only one thread can send a message> >// at a time.> >synchronized> (sender)> >{> >// synchronizing the send object> >sender.send(msg);> >}> >}> }> // Driver class> class> SyncDemo {> >public> static> void> main(String args[])> >{> >Sender send =>new> Sender();> >ThreadedSend S1 =>new> ThreadedSend(>' Hi '>, send);> >ThreadedSend S2 =>new> ThreadedSend(>' Bye '>, send);> >// Start two threads of ThreadedSend type> >S1.start();> >S2.start();> >// wait for threads to end> >try> {> >S1.join();> >S2.join();> >}> >catch> (Exception e) {> >System.out.println(>'Interrupted'>);> >}> >}> }> |
gitterlayout
>
>Produktion
Sending Hi Hi Sent Sending Bye Bye Sent>
Outputtet er det samme, hver gang vi kører programmet.
Forklaring
I ovenstående eksempel vælger vi at synkronisere Sender-objektet inde i run()-metoden i ThreadedSend-klassen. Alternativt kunne vi definere hele send() blok som synkroniseret , giver samme resultat. Så behøver vi ikke at synkronisere Message-objektet inde i run()-metoden i ThreadedSend-klassen.
// An alternate implementation to demonstrate // that we can use synchronized with method also. class Sender { public synchronized void send(String msg) { System.out.println('Sending ' + msg); try { Thread.sleep(1000); } catch (Exception e) { System.out.println('Thread interrupted.'); } System.out.println('
' + msg + 'Sent'); } }> Vi behøver ikke altid at synkronisere en hel metode. Nogle gange er det at foretrække synkronisere kun en del af en metode . Java-synkroniserede blokke inde i metoder gør dette muligt.
// One more alternate implementation to demonstrate // that synchronized can be used with only a part of // method class Sender { public void send(String msg) { synchronized(this) { System.out.println('Sending ' + msg ); try { Thread.sleep(1000); } catch (Exception e) { System.out.println('Thread interrupted.'); } System.out.println('
' + msg + 'Sent'); } } }> Eksempel på den synkroniserede metode ved brug af en anonym klasse
Java
java iterate kort
imessage spil til Android
// Java Pogram to synchronized method by> // using an anonymous class> import> java.io.*;> class> Test {> >synchronized> void> test_function(>int> n)> >{> >// synchronized method> >for> (>int> i =>1>; i <=>3>; i++) {> >System.out.println(n + i);> >try> {> >Thread.sleep(>500>);> >}> >catch> (Exception e) {> >System.out.println(e);> >}> >}> >}> }> // Driver Class> public> class> GFG {> >// Main function> >public> static> void> main(String args[])> >{> >// only one object> >final> Test obj =>new> Test();> >Thread a =>new> Thread() {> >public> void> run() { obj.test_function(>15>); }> >};> >Thread b =>new> Thread() {> >public> void> run() { obj.test_function(>30>); }> >};> >a.start();> >b.start();> >}> }> |
>
>Produktion
16 17 18 31 32 33>