Programma's met meerdere threads kunnen vaak in een situatie terechtkomen waarin meerdere threads proberen toegang te krijgen tot dezelfde bronnen en uiteindelijk foutieve en onvoorziene resultaten opleveren.
Waarom Java-synchronisatie gebruiken?
Java-synchronisatie wordt gebruikt om er door een bepaalde synchronisatiemethode voor te zorgen dat slechts één thread op een bepaald moment toegang heeft tot de bron.
je s t
Java-gesynchroniseerde blokken
Java biedt een manier om threads te maken en hun taken te synchroniseren met behulp van gesynchroniseerde blokken.
Een gesynchroniseerd blok in Java wordt op een object gesynchroniseerd. Alle gesynchroniseerde blokken worden op hetzelfde object gesynchroniseerd en er kan slechts één thread tegelijk in worden uitgevoerd. Alle andere threads die proberen het gesynchroniseerde blok binnen te komen, worden geblokkeerd totdat de thread binnen het gesynchroniseerde blok het blok verlaat.
Opmerking: Gesynchroniseerde blokken in Java worden gemarkeerd met het gesynchroniseerde sleutelwoord.
Algemene vorm van gesynchroniseerd 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 }> Deze synchronisatie wordt in Java geïmplementeerd met een concept dat monitors of locks wordt genoemd. Er kan slechts één thread tegelijk eigenaar zijn van een monitor. Wanneer een draad een slot krijgt, wordt er gezegd dat deze de monitor is binnengegaan. Alle andere threads die proberen de vergrendelde monitor binnen te dringen, worden opgeschort totdat de eerste thread de monitor verlaat.
Soorten synchronisatie
Er zijn twee synchronisaties in Java die hieronder worden vermeld:
- Processynchronisatie
- Synchronisatie van threads
1. Processynchronisatie in Java
Processynchronisatie is een techniek die wordt gebruikt om de uitvoering van meerdere processen te coördineren. Het zorgt ervoor dat de gedeelde bronnen veilig en in orde zijn.
2. Threadsynchronisatie in Java
Threadsynchronisatie wordt gebruikt om de uitvoering van de threads in een programma met meerdere threads te coördineren en te ordenen. Er zijn twee soorten threadsynchronisatie die hieronder worden vermeld:
- Wederzijds exclusief
- Samenwerking (communicatie tussen threads op Java)
Wederzijds exclusief
Mutual Exclusive zorgt ervoor dat threads elkaar niet hinderen tijdens het delen van gegevens. Hieronder worden drie soorten Mutual Exclusive genoemd:
- Gesynchroniseerde methode.
- Gesynchroniseerd blok.
- Statische synchronisatie.
Voorbeeld van synchronisatie
Hieronder ziet u de implementatie van de Java-synchronisatie:
Java
algoritme voor binair zoeken
heap en heap sorteren
// 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'>);> >}> >}> }> |
>
>Uitvoer
Sending Hi Hi Sent Sending Bye Bye Sent>
De uitvoer is elke keer dat we het programma uitvoeren hetzelfde.
Uitleg
In het bovenstaande voorbeeld kiezen we ervoor om het Sender-object te synchroniseren binnen de run() -methode van de ThreadedSend-klasse. Als alternatief zouden we de het hele send()-blok zoals gesynchroniseerd , hetzelfde resultaat opleveren. Dan hoeven we het Message-object niet te synchroniseren binnen de run() -methode in de ThreadedSend-klasse.
// 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'); } }> We hoeven niet altijd een hele methode te synchroniseren. Soms verdient dit de voorkeur synchroniseer slechts een deel van een methode . Gesynchroniseerde Java-blokken binnen methoden maken dit mogelijk.
javascript-tutorial
// 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'); } } }> Voorbeeld van de gesynchroniseerde methode met behulp van een anonieme klasse
Java
instellingenmenu 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();> >}> }> |
>
>Uitvoer
16 17 18 31 32 33>