Leitfaden zur Synchronisierung in Java
Veröffentlicht: 2022-10-23Bevor wir die Synchronisation in Java erläutern , müssen wir kurz auf das Konzept des Multithreading zurückkommen. Die Multithreading-Funktion von Java ermöglicht die gleichzeitige Ausführung von zwei oder mehr Teilen eines Programms für maximale CPU-Auslastung. Jeder Teil eines solchen Programms ist ein Thread, und Threads sind leichtgewichtige Prozesse innerhalb eines Prozesses.
Nun können mehrere Threads eines Programms versuchen, auf dieselben Ressourcen zuzugreifen, und ungenaue Ergebnisse liefern. Daher muss eine gewisse Synchronisierung vorhanden sein, um sicherzustellen, dass zu einem bestimmten Zeitpunkt nur ein Thread Zugriff auf Ressourcen hat.
Schauen Sie sich unsere kostenlosen Technologiekurse an, um sich einen Wettbewerbsvorteil zu verschaffen.
In diesem Leitfaden zur Synchronisation in Java wird das Konzept der Synchronisation anhand von Beispielen im Detail untersucht.
Lernen Sie Softwareentwicklungskurse online von den besten Universitäten der Welt. Verdienen Sie Executive PG-Programme, Advanced Certificate-Programme oder Master-Programme, um Ihre Karriere zu beschleunigen.
Was ist Synchronisation in Java?
Java-Synchronisation ist die Fähigkeit, den Zugriff mehrerer Threads auf eine gemeinsam genutzte Ressource zu steuern. Dies ist nützlich, wenn Java-Programme mit mehreren Threads versuchen, auf dieselbe Ressource zuzugreifen, und fehlerhafte Ergebnisse liefern. Bei Verwendung der Java-Synchronisationsfunktion kann zu einem bestimmten Zeitpunkt nur ein einzelner Thread auf die Ressource zugreifen.
Java bietet eine Möglichkeit, die Aufgabe von Threads zu synchronisieren, indem synchronisierte Blöcke verwendet werden, die auf demselben Objekt synchronisieren und in denen jeweils nur ein Thread ausgeführt werden kann. Diese Blöcke sind mit dem Schlüsselwort „synchronized“ markiert und blockieren jeden anderen Thread, der versucht, in den synchronisierten Block zu gelangen, bis der Thread, der sich bereits im Block befindet, seine Ausführung beendet und den Block verlässt.
Sehen Sie sich die erweiterte Zertifizierung von upGrad in DevOps an
Die Syntax zum Schreiben eines synchronisierten Blocks
Die allgemeine Syntax zum Schreiben eines synchronisierten Blocks in Java lautet wie folgt:
synchronisiert ( lockObject )
{
// synchronisierte Anweisungen
}
Erkunden Sie unsere beliebten Softwareentwicklungskurse
Master of Science in Informatik von LJMU & IIITB | Caltech CTME Cybersecurity-Zertifikatsprogramm |
Full-Stack-Entwicklungs-Bootcamp | PG-Programm in Blockchain |
Executive PG-Programm in der Full-Stack-Entwicklung | |
Sehen Sie sich unten alle unsere Kurse an | |
Software-Engineering-Kurse |
In der obigen Syntax bezieht sich lockObject auf ein Objekt, dessen Sperre sich auf die synchronisierten Elemente bezieht. Das bringt uns nun zum Lock-Konzept in Java.
Informieren Sie sich über die Advanced Certification in Cyber Security von upGrad
Sperren in Java
Die Synchronisierung in Java ist um die Sperre oder den Monitor herum aufgebaut. Jedes Objekt hat eine zugeordnete Sperre. Idealerweise muss ein Thread, der Zugriff auf die Felder eines Objekts benötigt, zuerst die Sperre des Objekts erlangen. Die Sperre ist ein ausgefeilterer und flexiblerer Thread-Synchronisationsmechanismus als der Synchronisationsblock. Es ist im Paket java.util.concurrent.lock definiert, das umfangreiche Sperrimplementierungen enthält.
Gefragte Fähigkeiten in der Softwareentwicklung
JavaScript-Kurse | Core-Java-Kurse | Kurse zu Datenstrukturen |
Node.js-Kurse | SQL-Kurse | Full-Stack-Entwicklungskurse |
NFT-Kurse | DevOps-Kurse | Big-Data-Kurse |
React.js-Kurse | Cyber-Sicherheitskurse | Cloud-Computing-Kurse |
Datenbankdesign-Kurse | Python-Kurse | Kryptowährungskurse |
Java-synchronisierte Methode
Der Zweck eines synchronisierten Java-Verfahrens besteht darin, Objekte für gemeinsam genutzte Ressourcen zu sperren. Wenn Threads also eine synchronisierte Methode aufrufen, erhält die Methode automatisch die Sperre für dieses Objekt und gibt sie frei, sobald der Thread seine Aufgabe ausgeführt hat.
Hier ist ein Beispiel für eine Java-synchronisierte Methode:
//Beispiel einer synchronisierten Java-Methode
Klassentabelle{
synchronisiert void printTable(int n){//synchronisierte Methode
for(int i=1;i<=5;i++){
System.out.println(n*i);
Versuchen{
Thread.sleep(400);
}catch(Exception e){System.out.println(e);}
}
}
}
Klasse MyThread1 erweitert Thread{
Tabelle t;
MyThread1(Tabelle t){
this.t=t;
}
öffentlich void run () {
t.printTable(5);
}
}
Klasse MyThread2 erweitert Thread{
Tabelle t;
MyThread2(Tabelle t){
this.t=t;
}
öffentlich void run () {
t.printTable(100);
}
}
öffentliche Klasse TestSynchronization2{
public static void main(String args[]){
Table obj = new Table();//nur ein Objekt
MyThread1 t1=new MyThread1(obj);
MyThread2 t2=new MyThread2(obj);
t1.start();
t2.start();
}
}
Lesen Sie unsere beliebten Artikel zur Softwareentwicklung
Wie implementiert man Datenabstraktion in Java? | Was ist die innere Klasse in Java? | Java-Identifikatoren: Definition, Syntax und Beispiele |
Verstehen der Kapselung in OOPS mit Beispielen | Befehlszeilenargumente in C erklärt | Top 10 Merkmale und Merkmale von Cloud Computing im Jahr 2022 |
Polymorphismus in Java: Konzepte, Typen, Eigenschaften und Beispiele | Pakete in Java und wie man sie verwendet? | Git-Tutorial für Anfänger: Lernen Sie Git von Grund auf neu |
Ausgabe:
5
10
fünfzehn
20
25
100
200
300
400
500
Was passiert ohne Synchronisierung?
Sehen wir uns nun das vorherige Programm ohne Synchronisation an (beachten Sie das Fehlen des Schlüsselworts „synced“).
Klassentabelle{
void printTable(int n){//Methode nicht synchronisiert
for(int i=1;i<=5;i++){
System.out.println(n*i);
Versuchen{
Thread.sleep(400);
}catch(Exception e){System.out.println(e);}
}
}
}
Klasse MyThread1 erweitert Thread{
Tabelle t;
MyThread1(Tabelle t){
this.t=t;
}
öffentlich void run () {
t.printTable(5);
}
}
Klasse MyThread2 erweitert Thread{
Tabelle t;
MyThread2(Tabelle t){
this.t=t;
}
öffentlich void run () {
t.printTable(100);
}
}
Klasse TestSynchronization1{
public static void main(String args[]){
Table obj = new Table();//nur ein Objekt
MyThread1 t1=new MyThread1(obj);
MyThread2 t2=new MyThread2(obj);
t1.start();
t2.start();
}
}
Ausgabe:
5
100
10
200
fünfzehn
300
20
400
25
500
Wie Sie sehen können, ist die Ausgabe ohne Synchronisation inkonsistent.
Arten der Synchronisierung in Java
Um zu beantworten, was Thread-Synchronisation in Java ist, stehen zwei Arten der Synchronisation zur Verfügung: Thread-Synchronisation und Prozess-Synchronisation.
Lassen Sie uns verstehen, was jedes bedeutet.
Thread-Synchronisation: Wenn mehrere Threads versuchen, auf eine gemeinsam genutzte Ressource zuzugreifen, müssen wir sicherstellen, dass die Ressource jeweils nur von einem Thread verwendet wird. Threadsynchronisierung ist der Prozess, bei dem nur ein Thread die gemeinsam genutzte Ressource verwenden kann, wenn mehrere Threads versuchen, die Ressource gleichzeitig zu verwenden.
Prozesssynchronisierung: Es bezieht sich auf die gleichzeitige Ausführung mehrerer Prozesse, um einen Zustand zu erreichen, in dem sich die Prozesse auf eine geeignete Ausführungsreihenfolge festlegen. Prozesssynchronisierung ist erforderlich, wenn zwei oder mehr Prozesse kooperieren und die Ausführung eines Prozesses den anderen beeinflusst. Somit eliminiert die Prozesssynchronisierung die Möglichkeit ungenauer Ausgaben und garantiert die richtige Ausführungsreihenfolge.
Methoden der Synchronisierung in Java
Im Großen und Ganzen gibt es in Java vier Synchronisationsmethoden:
- Synchronisierte statische Methoden
- Synchronisierte Instanzmethoden
- Synchronisierter Block innerhalb statischer Methoden
- Synchronisierter Block innerhalb von Instanzmethoden
Sehen wir uns die einzelnen Methoden der Java-Synchronisation genauer an.
Synchronisierte statische Methoden
Hier verwenden wir das Schlüsselwort "synced", um die statischen Methoden in Java zu markieren. Hier ist ein Beispiel für eine Java-synchronisierte statische Methode:
öffentlicher statischer MyStaticCounter {
private statische Int-Anzahl = 0;
öffentliches statisches synchronisiertes void-Inkrement (int-Wert) {
Anzahl += Wert;
}
}
Synchronisierte Instanzmethoden
Bei Verwendung eines synchronisierten Blocks mit Instanzmethoden hat jedes Objekt seine synchronisierte Methode. Jedes Objekt kann nur einen Thread haben, der innerhalb einer Methode ausgeführt werden kann. Wenn mehrere Objekte vorhanden sind, kann ein einzelner Thread für jedes Objekt innerhalb des Blocks ausgeführt werden.
öffentliche Klasse MyCounter {
private int-Anzahl = 0;
öffentliches synchronisiertes void-Inkrement (int-Wert) {
this.count += wert;
}
öffentliches synchronisiertes void-Dekrement (int-Wert) {
this.count -= Wert;
}
}
Synchronisierter Block innerhalb statischer Methoden
Unten sehen Sie ein Beispiel, in dem wir einen synchronisierten Block innerhalb einer statischen Methode verwenden:
öffentliche Klasse MyClass {
public static void print(String message) {
synchronisiert (MyClass.class) {
log.writeln (Nachricht);
}
}
}
Synchronisierter Block innerhalb von Instanzmethoden
Anstatt die gesamte Methode zu synchronisieren, können wir für einen bestimmten Block innerhalb der Methode „synced“ verwenden. Unten sehen Sie ein Beispiel für einen synchronisierten Codeblock innerhalb einer nicht synchronisierten Methode:
public void increment(int value) {
synchronisiert (dies) {
this.count += wert;
}
}
Notwendigkeit der Synchronisierung in Java
Jetzt, da Sie wissen, was Synchronisation in Java ist, fragen Sie sich vielleicht, warum wir es überhaupt verwenden.
Das Java-Synchronized-Schlüsselwort stellt Funktionalitäten bereit, die für die gleichzeitige Programmierung wesentlich sind. So hilft die Synchronisierung in Java:
- Die Java-Synchronisation bietet die Sperrfunktion, um jede Racebedingung zwischen Threads zu eliminieren und einen sich gegenseitig ausschließenden Zugriff auf die gemeinsam genutzte Ressource sicherzustellen.
- Die synchronisierte Java-Sperre bietet sowohl Sperr- als auch Entsperrfunktionen. Daher muss ein Thread die Sperre erwerben, bevor er in eine synchronisierte Methode oder einen synchronisierten Block eintritt.
- Das Schlüsselwort "synced" verhindert die Neuordnung von Programmanweisungen durch den Compiler.
Fazit
Zusammenfassend stellt die Synchronisation in Java sicher, dass jeweils nur ein Thread auf die gemeinsam genutzte Ressource zugreifen kann. Wir können einen Block oder eine Methode mit dem Java-Schlüsselwort „synced“ synchronisieren. Wenn ein Thread in einen synchronisierten Block gelangen möchte, muss er eine Sperre erwerben, und nach dem Verlassen des Blocks gibt der Thread die Sperre frei. Wir können das Schlüsselwort „synced“ entweder mit Methoden oder innerhalb des Blocks einer Methode verwenden.
Möchten Sie die Kernkonzepte von Java lernen? Das upGrad Executive Postgraduiertenprogramm in Softwareentwicklung – Spezialisierung auf Full-Stack-Entwicklung ist ein 7-wöchiges Online-Programm für Anfänger, die Karrieren in der Softwareentwicklung erkunden möchten. Nehmen Sie an Live- und interaktiven Kursen, Übungssitzungen und über 35 Stunden an Inhalten teil, die von Branchenführern bereitgestellt werden, um ein Abschlusszertifikat von upGrad zu erhalten.
Melden Sie sich noch heute an, um die exklusiven upGrad-Vorteile von 24/7-Studentenunterstützung und Branchennetzwerken zu nutzen!
Warum verwenden wir in Java synchronisiert?
Das Schlüsselwort „synced“ in Java stellt sicher, dass jeweils nur ein Thread auf die gemeinsam genutzten Ressourcen zugreifen kann. Dies ist nützlich, wenn Multithread-Java-Programme versuchen, auf dieselbe Ressource zuzugreifen, und ungenaue Ergebnisse liefern.
Wie wird die Synchronisation in Java implementiert?
Java implementiert die Synchronisation unter Verwendung des Konzepts von Monitoren, wobei jeweils nur ein Thread einen Monitor besitzt. Wenn ein Thread eine Sperre erwirbt, erhält er Zugriff auf den Monitor, und alle anderen Threads, die versuchen, in den gesperrten Monitor zu gelangen, bleiben blockiert, bis der erste Thread den Monitor verlässt.
Was ist ein Deadlock in Java?
Ein Java-Deadlock tritt auf, wenn ein Thread auf eine Objektsperre wartet, aber ein anderer Thread diese erwirbt und der zweite Thread auf eine Objektsperre wartet, die der erste erlangt hat. Daher warten beide Threads aufeinander, um die Sperre freizugeben, was zu einem Deadlock führt.