Synchronisation in Java | Erklärt

Wenn wir zwei oder mehr Threads im selben Programm beginnen, besteht die Möglichkeit, dass die mehreren Threads versuchen, auf dieselbe Ressource zuzugreifen, und folglich werden inkonsistente Ergebnisse erzeugt. Und um eine zuverlässige Kommunikation zwischen den mehreren Threads zu liefern, wird das Konzept der Synchronisation in Java verwendet. Das synchronisierte Schlüsselwort in Java synchronisiert die Aktionen mehrerer Threads und stellt sicher, dass nur ein Thread zu einem bestimmten Zeitpunkt auf eine bestimmte Ressource zugreifen kann.

In diesem Artikel werden die verschiedenen Aspekte der Synchronisation in Java untersucht. In diesem Artikel wird in diesem Artikel die folgenden Konzepte behandelt:

• Was ist Synchronisation in Java?
• Warum wird die Synchronisation verwendet??
• Warum synchronisierte Schlüsselwort in Java verwendet wird
• So verwenden Sie die Synchronisation in Java

Also, lass uns gehen

Was ist Synchronisation in Java?

Es ist ein Prozess, der den Zugriff von mehr als einem Thread auf eine gemeinsame Ressource steuert und daher inkonsistente Ergebnisse vermeidet.

Warum wird die Synchronisation verwendet??

In Java besteht der Hauptzweck bei der Verwendung der Synchronisation darin, das inkonsistente Verhalten von Threads zu vermeiden und Interferenzen zu verhindern.

Warum synchronisierte Schlüsselwort in Java verwendet wird

Synchronisiert ist ein Modifikator, der nur auf die Methoden und Blöcke angewendet werden kann und nicht auf Variablen und Klassen angewendet werden kann. Um dieses Konzept zu verstehen

So verwenden Sie die Synchronisation in Java

Wir werden einige Beispiele für ein tiefes Verständnis berücksichtigen. Zunächst werden wir ein sehr einfaches Java -Programm erstellen, um den Wert des Zählers zu erhöhen. Als nächstes werden wir dieses Beispiel auf das Multithread -Szenario erweitern. Allmählich werden wir uns auf die Synchronisation befassen, wo wir erfahren, warum das synchronisierte Schlüsselwort in Java verwendet wird?

Beispiel
In diesem Beispiel werden wir ein einfaches Programm mit einer Variablen erstellen Schalter und eine benutzerdefinierte Funktion IncrementValue ().

Klasse Gegenklasse
int counter;
public void IncrementValue ()
Zähler ++;


öffentliche Klasse Synchronization Example
public static void main (String [] args)
Coterclass count = neuer conter class ();
zählen.IncrementValue ();
System.aus.println ("Zähler:" + zählen.Schalter);

Wann immer wir das aufrufen IncrementValue () es wird den Wert von erhöht Schalter durch 1:

Der Wert des Zählers wird erfolgreich auf 1 erhöht, was die Angemessenheit unseres Programms zeigt. Wenn wir das anrufen IncrementValue () Methode zweimal, dann wird der Wert des Zählers 2. In ähnlicher Weise wird der Wert von Zähler als 3 angezeigt, wenn wir das anrufen IncrementValue () Methode dreimal, wie im folgenden Snippet gezeigt:

Im obigen Code -Snippet haben wir die aufgerufen IncrementValue () Methode viermal, so dass es den Wert von Zähler als 4 zeigt.

Beispiel
Lassen Sie uns nun das obige Beispiel ein wenig erweitern, wo wir einen Thread erstellen, der den IncrementValue () zehnmal aufruft:

Klasse Gegenklasse
int counter;
public void IncrementValue ()
Zähler ++;


öffentliche Klasse Synchronization Example
public static void main (String [] args) löst Ausnahme aus
Coterclass count = neuer conter class ();
Thread Th1 = neuer Thread (neuer Runnable ()
public void run ()
für (int i = 1; i <= 10; i++)
zählen.IncrementValue ();


);
Th1.Start();
Th1.verbinden();
System.aus.println ("Zähler:" + zählen.Schalter);

In der obigen Codes-Snippet-Methode wird mit dem Objekt der Thread-Klasse die Methode angewendet, sodass ein Thread warten sollte, bis der andere Thread die Ausführung abschließt. Das obige Code-Snippet erzeugt die folgende Ausgabe:

Aus der Ausgabe ist klar, dass Thread die aufruft IncrementValue () zehnmal und daher ist der Wert des Zählers gleich zehn.

Soweit so gut, jetzt betrachten wir eine Multithread -Umgebung und erstellen einen weiteren Thread, um zu sehen, was passieren wird, wenn zwei Threads dieselbe Ressource fordern (ich.e. IncrementValue () Methode) gleichzeitig.

Beispiel

In diesem Beispiel haben wir zwei Threads, die beide fünfhundertmal die IncrementValue () -Methode aufrufen:

Klasse Gegenklasse
int counter;
public void IncrementValue ()
Zähler ++;


öffentliche Klasse Synchronization Example
public static void main (String [] args) löst Ausnahme aus
Coterclass count = neuer conter class ();
Thread Th1 = neuer Thread (neuer Runnable ()
public void run ()
für (int i = 1; i <= 500; i++)
zählen.IncrementValue ();


);
Thread th2 = neuer Thread (neuer Runnable ()
public void run ()
für (int i = 1; i <= 500; i++)
zählen.IncrementValue ();


);
Th1.Start();
Th1.verbinden();
Th2.Start();
Th2.verbinden();
System.aus.println ("Zähler:" + zählen.Schalter);

Da beide Threads das Gegenwert () fünfhundert Mal aufrufen, sollte der Wert des Inkrements technisch tausend betragen. Betrachten wir den folgenden Snippet, um zu sehen, was die Ausgabe sagt:

Anstelle von „1000“ erhalten wir "753", was bedeutet das nun das, was das bedeutet? Warum haben wir nicht den Wert des Zählers als 1000 bekommen??

Nun, es liegt daran, dass Multithreading die parallele Verarbeitung unterstützt und daher immer die Möglichkeit besteht Wert des Zählers zweimal, er erhöht nur einmal.

So vermeiden Sie ein solches Szenario? Also! In solchen Fällen wird das synchronisierte Schlüsselwort verwendet.

Beispiel
Wir werden das synchronisierte Schlüsselwort mit dem “verwendenIncrementValue ()"Methode als Ergebnis Nur ein Thread greift auf die" zu "IncrementValue ()”Methode gleichzeitig. Der gesamte Code bleibt der gleiche wie im vorherigen Beispiel, das nur synchronisierte Schlüsselwort mit der Methode IncrementValue () hinzugefügt wird, wie im Snippet gezeigt:

public synchronisierte void IncrementValue ()
Zähler ++;

Wenn Thread 1 nun mit dem arbeitet IncrementValue () Methode dann wird Thread 2 warten und umgekehrt. Dieses Mal erhalten wir die folgende Ausgabe:

Das oben gegebene Snippet zeigt die Wirksamkeit des Schlüsselworts „Synchronisiert“.

Abschluss

Die Synchronisation ist ein Prozess, der den Zugriff von mehr als einem Thread steuert und sicherstellt, dass nur ein Thread zu einem bestimmten Zeitpunkt auf die Ressource zugreifen kann. Um eine Synchronisation zu erreichen, wird das synchronisierte Schlüsselwort/Modifikator verwendet und kann auf die Methoden und Blöcke angewendet werden, kann jedoch nicht auf Variablen und Klassen angewendet werden. In Java besteht der Hauptzweck bei der Verwendung der Synchronisation darin, das inkonsistente Verhalten von Threads zu vermeiden und Interferenzen zu verhindern.