logo

TechCodeview

Synchronisierung in Java

Unter Synchronisierung versteht man in Java die Möglichkeit, den Zugriff mehrerer Threads auf eine beliebige gemeinsam genutzte Ressource zu steuern.

Die Java-Synchronisierung ist die bessere Option, wenn wir nur einem Thread den Zugriff auf die gemeinsam genutzte Ressource ermöglichen möchten.

Warum Synchronisierung verwenden?

Die Synchronisation dient hauptsächlich dazu

  1. Um Fadeninterferenzen zu vermeiden.
  2. Um Konsistenzprobleme zu vermeiden.

Arten der Synchronisierung

Es gibt zwei Arten der Synchronisierung

  1. Prozesssynchronisierung
  2. Thread-Synchronisierung

Hier besprechen wir nur die Thread-Synchronisierung.

Thread-Synchronisierung

Es gibt zwei Arten der Thread-Synchronisation, gegenseitige Exklusivität und Inter-Thread-Kommunikation.

  1. Gegenseitiger Ausschluss
    1. Synchronisierte Methode.
    2. Synchronisierter Block.
    3. Statische Synchronisierung.
  2. Zusammenarbeit (Inter-Thread-Kommunikation in Java)

Gegenseitiger Ausschluss

Mutual Exclusive verhindert, dass Threads sich beim Datenaustausch gegenseitig stören. Dies kann durch die folgenden drei Möglichkeiten erreicht werden:

  1. Durch die Verwendung der synchronisierten Methode
  2. Durch die Verwendung eines synchronisierten Blocks
  3. Durch Verwendung der statischen Synchronisierung

Konzept der Sperre in Java

Die Synchronisierung basiert auf einer internen Einheit, die als Sperre oder Monitor bezeichnet wird. Jedem Objekt ist eine Sperre zugeordnet. Konventionell muss ein Thread, der konsistenten Zugriff auf die Felder eines Objekts benötigt, die Sperre des Objekts erwerben, bevor er auf sie zugreift, und die Sperre dann aufheben, wenn er damit fertig ist.

Ab Java 5 enthält das Paket java.util.concurrent.locks mehrere Sperrimplementierungen.

Das Problem ohne Synchronisierung verstehen

In diesem Beispiel gibt es keine Synchronisierung, daher ist die Ausgabe inkonsistent. Sehen wir uns das Beispiel an:

TestSynchronization1.java 

 class Table{ void printTable(int n){//method not synchronized for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } class mythread1 extends thread{ table t; mythread1(table t){ this.t="t;" public void run(){ t.printtable(5); mythread2 mythread2(table t.printtable(100); testsynchronization1{ static main(string args[]){ obj="new" table(); only one object t1="new" mythread1(obj); t2="new" mythread2(obj); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 100 10 200 15 300 20 400 25 500 </pre> <h3>Java Synchronized Method</h3> <p>If you declare any method as synchronized, it is known as synchronized method.</p> <p>Synchronized method is used to lock an object for any shared resource.</p> <p>When a thread invokes a synchronized method, it automatically acquires the lock for that object and releases it when the thread completes its task.</p> <p> <strong>TestSynchronization2.java</strong> </p> <pre> //example of java synchronized method class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } class mythread1 extends thread{ table t; mythread1(table t){ this.t="t;" public void run(){ t.printtable(5); mythread2 mythread2(table t.printtable(100); testsynchronization2{ static main(string args[]){ obj="new" table(); only one object t1="new" mythread1(obj); t2="new" mythread2(obj); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <h3>Example of synchronized method by using annonymous class</h3> <p>In this program, we have created the two threads by using the anonymous class, so less coding is required.</p> <p> <strong>TestSynchronization3.java</strong> </p> <pre> //Program of synchronized method by using annonymous class class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } public class testsynchronization3{ static void main(string args[]){ final table obj="new" table(); only one object thread t1="new" thread(){ run(){ obj.printtable(5); }; t2="new" obj.printtable(100); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <hr></=5;i++){></pre></=5;i++){></pre></=5;i++){>

Java-synchronisierte Methode

Wenn Sie eine Methode als synchronisiert deklarieren, wird sie als synchronisierte Methode bezeichnet.

Die synchronisierte Methode wird verwendet, um ein Objekt für eine beliebige gemeinsam genutzte Ressource zu sperren.

Wenn ein Thread eine synchronisierte Methode aufruft, erhält er automatisch die Sperre für dieses Objekt und gibt sie frei, wenn der Thread seine Aufgabe abgeschlossen hat.

TestSynchronization2.java 

 //example of java synchronized method class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } class mythread1 extends thread{ table t; mythread1(table t){ this.t="t;" public void run(){ t.printtable(5); mythread2 mythread2(table t.printtable(100); testsynchronization2{ static main(string args[]){ obj="new" table(); only one object t1="new" mythread1(obj); t2="new" mythread2(obj); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <h3>Example of synchronized method by using annonymous class</h3> <p>In this program, we have created the two threads by using the anonymous class, so less coding is required.</p> <p> <strong>TestSynchronization3.java</strong> </p> <pre> //Program of synchronized method by using annonymous class class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } public class testsynchronization3{ static void main(string args[]){ final table obj="new" table(); only one object thread t1="new" thread(){ run(){ obj.printtable(5); }; t2="new" obj.printtable(100); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <hr></=5;i++){></pre></=5;i++){>

Beispiel einer synchronisierten Methode unter Verwendung einer anonymen Klasse

In diesem Programm haben wir die beiden Threads mithilfe der anonymen Klasse erstellt, sodass weniger Codierung erforderlich ist.

TestSynchronization3.java 

 //Program of synchronized method by using annonymous class class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } public class testsynchronization3{ static void main(string args[]){ final table obj="new" table(); only one object thread t1="new" thread(){ run(){ obj.printtable(5); }; t2="new" obj.printtable(100); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <hr></=5;i++){>