Bei Multithread-Programmen kann es häufig vorkommen, dass mehrere Threads versuchen, auf dieselben Ressourcen zuzugreifen, und letztendlich fehlerhafte und unvorhergesehene Ergebnisse liefern.
Warum Java-Synchronisierung verwenden?
Mithilfe der Java-Synchronisierung wird durch eine Synchronisierungsmethode sichergestellt, dass zu einem bestimmten Zeitpunkt nur ein Thread auf die Ressource zugreifen kann.
Heap und Heap-Sortierung
Java-synchronisierte Blöcke
Java bietet eine Möglichkeit, Threads zu erstellen und ihre Aufgaben mithilfe synchronisierter Blöcke zu synchronisieren.
Ein synchronisierter Block in Java wird mit einem Objekt synchronisiert. Alle synchronisierten Blöcke werden auf demselben Objekt synchronisiert und es kann jeweils nur ein Thread darin ausgeführt werden. Alle anderen Threads, die versuchen, in den synchronisierten Block einzutreten, werden blockiert, bis der Thread innerhalb des synchronisierten Blocks den Block verlässt.
Notiz: Synchronisierte Blöcke in Java werden mit dem synchronisierten Schlüsselwort gekennzeichnet.
Allgemeine Form des synchronisierten Blocks
// 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 }> Diese Synchronisierung wird in Java mit einem Konzept namens Monitore oder Sperren implementiert. Es kann jeweils nur ein Thread einen Monitor besitzen. Wenn ein Thread eine Sperre erhält, gilt er als in den Monitor eingetreten. Alle anderen Threads, die versuchen, den gesperrten Monitor zu betreten, werden angehalten, bis der erste Thread den Monitor verlässt.
Arten der Synchronisierung
Es gibt zwei Synchronisierungen in Java, die unten erwähnt werden:
- Prozesssynchronisation
- Thread-Synchronisierung
1. Prozesssynchronisation in Java
Prozesssynchronisation ist eine Technik zur Koordinierung der Ausführung mehrerer Prozesse. Es stellt sicher, dass die gemeinsam genutzten Ressourcen sicher und in Ordnung sind.
2. Thread-Synchronisierung in Java
Die Thread-Synchronisierung wird verwendet, um die Ausführung der Threads in einem Multithread-Programm zu koordinieren und zu ordnen. Es gibt zwei Arten der Thread-Synchronisierung, die im Folgenden erwähnt werden:
- Gegenseitiger Ausschluss
- Kooperation (Inter-Thread-Kommunikation in Java)
Gegenseitiger Ausschluss
Mutual Exclusive verhindert, dass Threads sich beim Datenaustausch gegenseitig stören. Es gibt drei Arten des gegenseitigen Ausschlusses, die im Folgenden erwähnt werden:
- Synchronisierte Methode.
- Synchronisierter Block.
- Statische Synchronisierung.
Beispiel für Synchronisierung
Nachfolgend finden Sie die Implementierung der Java-Synchronisierung:
Java
Ordner unter Linux umbenennen
json im JSON-Beispiel
// 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'>);> >}> >}> }> |
>
>Ausgabe
Sending Hi Hi Sent Sending Bye Bye Sent>
Die Ausgabe ist jedes Mal dieselbe, wenn wir das Programm ausführen.
Erläuterung
Im obigen Beispiel entscheiden wir uns dafür, das Sender-Objekt innerhalb der run()-Methode der ThreadedSend-Klasse zu synchronisieren. Alternativ könnten wir das definieren gesamter send()-Block als synchronisiert , das gleiche Ergebnis hervorbringen. Dann müssen wir das Message-Objekt nicht innerhalb der run()-Methode in der ThreadedSend-Klasse synchronisieren.
// 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'); } }> Wir müssen nicht immer eine ganze Methode synchronisieren. Manchmal ist es besser Synchronisieren Sie nur einen Teil einer Methode . Möglich machen dies Java-synchronisierte Blöcke innerhalb von Methoden.
// 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'); } } }> Beispiel für die synchronisierte Methode unter Verwendung einer anonymen Klasse
Java
wenn von Rudyard Kipling Zeile für Zeile Erklärung
// 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();> >}> }> |
>
Was ist Rom?
>Ausgabe
16 17 18 31 32 33>