Synchronisierter Block in Java

In Java hilft ein Synchronized-Block bei der Synchronisierung einer bestimmten Ressource der Funktion oder Methode. Wenn 100 Codezeilen (LOC) vorhanden sind und die Synchronisierung nur für 10 Zeilen durchgeführt werden muss, kann ein synchronisierter Block verwendet werden. Synchronized kann als Schlüsselwort, Methode und Block verwendet werden. In diesem Tutorial werden wir den synchronisierten Block im Detail besprechen.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Syntax:

Die Syntax des synchronisierten Blocks ist wie folgt:

Synchronized( lo)
{
//statements that have to be synchronized
}

Hier ist das Sperrobjekt

Wie funktioniert synchronisierter Block in Java?

Wie bereits besprochen, hilft der Synchronized-Block bei der Synchronisierung einer bestimmten Ressource der Funktion oder Methode. Wenn ein Thread Zeilen ausführen muss, die innerhalb des synchronisierten Blocks synchronisiert sind, ist es zwingend erforderlich,  die Sperre auf dem Monitor des in der obigen Syntax erwähnten Sperrobjekts zu erwerben. Es kann jeweils nur ein Thread den Monitor des Sperrobjekts abrufen. Jeder Thread muss warten, bis der Thread, der derzeit die Sperre hält, die Ausführung abschließt und sie freigibt.

In ähnlicher Weise stellt das synchronisierte Schlüsselwort sicher, dass jeweils nur ein Thread die Codezeilen in einem synchronisierten Block ausführt, was wiederum verhindert, dass mehr als ein Thread die innerhalb des Blocks gemeinsam genutzten Daten beschädigt.

Angenommen, eine Methode besteht aus 500 LOC (Codezeilen), aber es gibt nur 20 Codezeilen, die einen kritischen Codeabschnitt (CS) enthalten. Das heißt, diese 20 Zeilen können den Zustand des Objekts verändern oder ändern. Daher kann eine Synchronisierung mit diesen 20 Codezeilen durchgeführt werden, um Änderungen im Objektstatus zu vermeiden und sicherzustellen, dass andere Threads die anderen 480 Zeilen innerhalb der jeweiligen Methode ohne Unterbrechung ausführen.

Beispiele für synchronisierte Blöcke in Java

Sehen wir uns nun einige Beispielprogramme im synchronisierten Block in Java an.

Beispiel #1

Java-Programm zur Implementierung eines synchronisierten Blocks

Code:

class Testsmple{
void printTestsmple(int n)
{
//start of synchronized block
synchronized(this)
{
System.out.println("The output of synchronized block is: ");
for( int i=1 ; i<=4 ; i++ )
{
System.out.println(n*i);
//exception handling
try
{
Thread.sleep(500);
}
catch(Exception exc)
{
System.out.println(exc) ;
}
}
}
} //end
}
class T1 extends Thread
{
Testsmple t;
T1(Testsmple t)
{
this.t=t;
}
public void run()
{
t.printTestsmple(10);
}
}
class T2 extends Thread
{
Testsmple t;
T2(Testsmple t)
{
this.t=t;
}
public void run()
{
t.printTestsmple(200);
}
}
public class SyncBlockExample
{
public static void main(String args[])
{
// create only one object
Testsmple ob = new Testsmple();
//objects of threads
T1 t1=new T1(ob);
T2 t2=new T2(ob);
//start the threads t1 and t2
t1.start();
t2.start();
}  }

Ausgabe:

In diesem Programm werden zwei Threads t1 und t2 verwendet, von denen jeder über eine Methode printTestsmple verfügt, die die synchronisierte Methode aufruft. Die Eingabe von Thread 1 für printTestsmple ist 10 und die Eingabe von Thread 2 ist 200. Aus dem Ergebnis ist ersichtlich, dass die Ausgabe des synchronisierten Blocks des ersten Threads 10, 20, 30, 40 beträgt. Gleichzeitig ist Das Ergebnis des synchronisierten Blocks von Thread 2 ist 200, 400, 600, 800. Darüber hinaus gibt es eine Zeile „Die Ausgabe des synchronisierten Blocks ist:“, die zwischen den Ergebnissen jedes Threads gedruckt wird.

Beispiel #2

Java-Programm zur Implementierung synchronisierter Blöcke mithilfe anonymer Klassen.

Code:

class Testsmple{
void printTestsmple(int n)
{
//start of synchronized block
synchronized(this)
{
System.out.println("The output of synchronized block is: ");
for( int i=1 ; i<=4 ; i++ )
{
System.out.println(n*i);
//exception handling
try
{
Thread.sleep(500);
}
catch(Exception exc)
{
System.out.println(exc) ;
}
}
}
} //end
}
public class SyncBlockExample
{
//main method
public static void main(String args[])
{
//create only one object
final Testsmple obj = new Testsmple() ;
//create thread th1
Thread th1=new Thread()
{
public void run()
{
obj.printTestsmple(10) ;
}
}
;
//create thread th2
Thread th2=new Thread()
{
public void run()
{
obj.printTestsmple(200);
}
} ;
th1.start() ;
th2.start() ;
}}

Ausgabe:

In diesem Programm werden außerdem zwei Threads t1 und t2 verwendet, von denen jeder über eine Methode printTestsmple verfügt, die die synchronisierte Methode aufruft. Die Eingabe von Thread 1 für printTestsmple ist 10 und die Eingabe von Thread 2 ist 200. Aus dem Ergebnis ist ersichtlich, dass die Ausgabe des synchronisierten Blocks des ersten Threads 10, 20, 30, 40 beträgt. Gleichzeitig ist Das Ergebnis des synchronisierten Blocks von Thread 2 ist 200, 400, 600, 800. Darüber hinaus gibt es eine Zeile „Die Ausgabe des synchronisierten Blocks ist:“, die zwischen den Ergebnissen jedes Threads gedruckt wird. Der einzige Unterschied besteht in der Anwesenheit einer anonymen Klasse in diesem Programm.

Beispiel #3

Java-Programm zur Implementierung eines synchronisierten Blocks.

import java.util.*;
class ABC
{
String nm = "";
public int cnt = 0;
public void samplename(String stringexample, List<String>li)
{
// In order to change the name at a time, only 1 thread is permitted
synchronized(this)
{
nm = stringexample;
cnt++;
}
li.add(stringexample);
}
}
public class SyncBlockExample
{
//main method
public static void main (String[] args)
{
//create an object for the class ABC
ABC obj = new ABC();
//create a list
List<String>li = new ArrayList<String>();
//call the method using the object created
obj.samplename("Anna Sam", li);
System.out.println(obj.nm);
}
}

Ausgabe:

In diesem Programm wird eine Klasse ABC mit einer synchronisierten Methode innerhalb der Methode Beispielname erstellt. Als Eingabe für den Aufruf der Methode samplename wird ein String „Anna Sam“ übergeben. Beim Ausführen des Codes wird die Zeichenfolge „Anna Sam“ gedruckt.

Vorteile

Einige der Vorteile sind unten aufgeführt:

• Leistungsverbesserungen können durchgeführt werden, wenn der Umfang der Synchronisierung begrenzt ist.
• Synchronisieren Sie kleine Codeblöcke, um den Rechenaufwand zu reduzieren.
• Flexibel, andere Objekte als Schlösser zu verwenden.
• Da Java eine Multithread-Programmiersprache ist, ist es am besten, einen gegenseitigen Ausschluss für gemeinsam genutzte Ressourcen zu erreichen.

Das obige ist der detaillierte Inhalt vonSynchronisierter Block in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!