Verwenden Sie den Java-synchronisierten Block für die Klasse

1. Verwenden Sie den Java-synchronisierten Block für die Klasse
2. Abschluss

In Java verwaltet die Synchronisation mehrere Threads, die auf Ressourcen zugreifen, die gemeinsam genutzt werden könnten. Die Synchronisierung in Java wird verwendet, damit Threads zuverlässig miteinander kommunizieren können, und sie gilt auch als die beste Option für einen einzelnen Thread, um auf gemeinsam genutzte Ressourcen zuzugreifen.

Das Schlüsselwort synchronized wird verwendet, um synchronisierte Blöcke zu markieren. Bei einigen Objekten ist der Java-Synchronisationsblock anwendbar.

Verwenden Sie den Java-synchronisierten Block für die Klasse

Wenn ein synchronisierter Block für dieselben Objekte mehrere Threads hat, würde er nur einem Thread erlauben, in den Block einzutreten und nur einen Thread gleichzeitig auszuführen. Alle anderen Threads würden blockiert bleiben.

Lassen Sie uns den Java-Synchronisationsblock für die Klasse zusammen mit Beispielen erklären.

Beispielcode:

class Block {
  // synchronized block starts from here
  void printBlock(int b) {
    synchronized (this) {
      System.out.println("The block output is: ");
      for (int j = 1; j <= 4; j++) {
        System.out.println(b * j);

        // handles exception
        try {
          Thread.sleep(500);
        } catch (Exception e) {
          System.out.println(e);
        }
      }
    }
  } // ending
}

class S1 extends Thread {
  Block s;
  S1(Block s) {
    this.s = s;
  }

  public void run() {
    s.printBlock(10);
  }
}

class S2 extends Thread {
  Block s;
  S2(Block s) {
    this.s = s;
  }

  public void run() {
    s.printBlock(200);
  }
}

class SyncBlock {
  // main method
  public static void main(String args[]) {
    // object creation
    Block obj = new Block();
    S1 s1 = new S1(obj);
    S2 s2 = new S2(obj);

    // run the threads s1 and s2
    s1.run();
    s2.run();
  }
}

Ausgang:

The block output is:
10
20
30
40
The block output is:
200
400
600
800

Im obigen Beispiel haben wir zwei Threads, S1 und S2. Beide Threads haben eine printBlock-Methode, die ihnen hilft, die synchronisierten Methoden aufzurufen.

Der S1-Thread-Eingabewert ist 10 und für S2 ist er 200. Dann wird die Blockausgabe zwischen den Ausgaben der S1- und S2-Threads gedruckt.

Beispielcode:

import java.util.*;

class synchronize {
  String title = "";
  public int c = 0;
  public void result(String s, List<String> li) {
    // only one thread is allowed to change the title simultaneously.
    synchronized (this) {
      title = s;
      c++;
    }

    li.add(s);
  }
}

class SyncBlock {
  // main method
  public static void main(String[] args) {
    // for synchronize class, we have created an object
    synchronize ob = new synchronize();

    // we have created a list here
    List<String> li = new ArrayList<String>();

    // for calling the method, a string is passed to it
    ob.result("Sprint Planning", li);
    System.out.println(ob.title);
  }
}

Ausgang:

Sprint Planning

Im obigen Beispiel wurde eine Klassensynchronisation erstellt. In dieser Klasse haben wir die synchronisierte Methode verwendet.

Als Eingabewert für den Methodenaufruf wird ein String übergeben. d.h. Sprint-Planung.

Wenn wir das obige Programm ausführen, erhalten wir als Ausgabe Sprint Planning.

Abschluss

Es gibt viele Möglichkeiten, Synchronisierungsblöcke in Java zu diskutieren, aber in diesem Artikel haben wir die Synchronisierung, Synchronisierungsblöcke und ihre Funktionsweise erklärt.

Wenn wir mehrere threads für ein Objekt gleichzeitig haben, können wir mit einem Synchronisationsblock nur einen Thread gleichzeitig ausführen. Die anderen Threads dürfen nicht in den Block eintreten, bis der Thread innerhalb des Blocks erfolgreich ausgeführt wurde.

So sorgt die synchronisierte Blockklasse in Java dafür, dass es zum Beispiel immer nur einen thread im Block geben darf.