Gibt es einen Vorteil, eine synchronisierte Methode anstelle eines synchronisierten Blocks zu verwenden?

Question

Kann mir jemand den Vorteil einer synchronisierten Methode gegenüber einem synchronisierten Block anhand eines Beispiels erläutern?

Answer 1

Wie schon gesagt, kann der synchronisierte Block eine benutzerdefinierte Variable als Lock-Objekt verwenden, während die synchronisierte Funktion nur "this" verwendet. Und natürlich kann man mit Bereichen der Funktion manipulieren, die synchronisiert werden sollen. Aber jeder sagt, dass es keinen Unterschied zwischen einer synchronisierten Funktion und einem Block gibt, der die gesamte Funktion abdeckt und "this" als Lock-Objekt verwendet. Das ist nicht wahr, der Unterschied liegt im Bytecode, der in beiden Situationen erzeugt wird. Im Falle eines synchronisierten Blocks sollte eine lokale Variable verwendet werden, die einen Verweis auf "this" enthält. Das Ergebnis ist, dass die Funktion etwas größer ist (nicht relevant, wenn Sie nur wenige Funktionen haben).

Eine genauere Erklärung des Unterschieds finden Sie hier: http://www.artima.com/insidejvm/ed2/threadsynchP.html

Answer 2

In der Praxis liegt der Vorteil von synchronisierten Methoden gegenüber synchronisierten Blöcken darin, dass sie idiotensicherer sind; da man kein beliebiges Objekt zum Sperren auswählen kann, kann man die Syntax der synchronisierten Methode nicht missbrauchen, um dumme Dinge zu tun, wie das Sperren eines String-Literal oder das Sperren des Inhalts eines veränderlichen Feldes, das unter den Threads verändert wird.

Andererseits können Sie bei synchronisierten Methoden die Sperre nicht davor schützen, dass sie von einem beliebigen Thread, der einen Verweis auf das Objekt erhalten kann, übernommen wird.

Die Verwendung von synchronized als Modifikator für Methoden ist also besser geeignet, um Ihre Coworker davor zu schützen, sich selbst zu verletzen, während die Verwendung von synchronisierten Blöcken in Verbindung mit privaten endgültigen Sperrobjekten besser geeignet ist, Ihren eigenen Code vor den Coworkern zu schützen.

Answer 3

Bei synchronisierten Methoden wird die Sperre auf ein Objekt angewendet. Wenn Sie jedoch einen synchronisierten Block verwenden, haben Sie die Möglichkeit, ein Objekt anzugeben, auf das die Sperre angewandt werden soll.

Beispiel:

    Class Example {
    String test = "abc";
    // lock will be acquired on String  test object.
    synchronized (test) {
        // do something
    }

   lock will be acquired on Example Object
   public synchronized void testMethod() {
     // do some thing
   } 

   }

Answer 4

Ich weiß, dass dies eine alte Frage ist, aber bei meiner schnellen Lektüre der Antworten hier, habe ich nicht wirklich gesehen, dass jemand erwähnt, dass manchmal ein synchronized Methode kann die falsch Schloss.
Aus Java Concurrency In Practice (S. 72):

public class ListHelper<E> {
  public List<E> list = Collections.syncrhonizedList(new ArrayList<>());
...

public syncrhonized boolean putIfAbsent(E x) {
 boolean absent = !list.contains(x);
if(absent) {
 list.add(x);
}
return absent;
}

Der obige Code hat die Aussehen thread-sicher zu sein. In Wirklichkeit ist sie es aber nicht. In diesem Fall wird die Sperre für die Instanz der Klasse erhalten. Es ist jedoch möglich, dass die Liste von einem anderen Thread geändert werden, der diese Methode nicht verwendet. Der richtige Ansatz wäre die Verwendung von

public boolean putIfAbsent(E x) {
 synchronized(list) {
  boolean absent = !list.contains(x);
  if(absent) {
    list.add(x);
  }
  return absent;
}
}

Der obige Code würde Folgendes blockieren alle Gewinde versuchen zu ändern Liste die Liste nicht zu ändern, bis der synchronisierte Block abgeschlossen ist.

Answer 5

Ich nehme an, diese Frage bezieht sich auf den Unterschied zwischen Threadsicheres Singleton y Faule Initialisierung mit Double Check Locking . Ich beziehe mich immer auf diesen Artikel, wenn ich ein bestimmtes Singleton implementieren muss.

Nun, dies ist ein Threadsicheres Singleton :

// Java program to create Thread Safe 
// Singleton class 
public class GFG  
{ 
  // private instance, so that it can be 
  // accessed by only by getInstance() method 
  private static GFG instance; 

  private GFG()  
  { 
    // private constructor 
  } 

 //synchronized method to control simultaneous access 
  synchronized public static GFG getInstance()  
  { 
    if (instance == null)  
    { 
      // if instance is null, initialize 
      instance = new GFG(); 
    } 
    return instance; 
  } 
} 

Vorteile:

1. Eine träge Initialisierung ist möglich.

2. Es ist fadensicher.

Nachteile:

1. getInstance()-Methode ist synchronisiert, so dass sie eine langsame Leistung verursacht, da mehrere Threads nicht gleichzeitig darauf zugreifen können.

Dies ist eine Faule Initialisierung mit Doppelkontrollsperre :

// Java code to explain double check locking 
public class GFG  
{ 
  // private instance, so that it can be 
  // accessed by only by getInstance() method 
  private static GFG instance; 

  private GFG()  
  { 
    // private constructor 
  } 

  public static GFG getInstance() 
  { 
    if (instance == null)  
    { 
      //synchronized block to remove overhead 
      synchronized (GFG.class) 
      { 
        if(instance==null) 
        { 
          // if instance is null, initialize 
          instance = new GFG(); 
        } 

      } 
    } 
    return instance; 
  } 
} 

Vorteile:

1. Eine träge Initialisierung ist möglich.

2. Außerdem ist es fadensicher.

3. Leistungseinbußen aufgrund von synchronisierten Schlüsselwörtern werden überwunden.

Nachteile:

1. Beim ersten Mal kann es die Leistung beeinträchtigen.

2. Da die Nachteile der Double-Check-Sperrmethode erträglich sind, kann sie für leistungsstarke Multithreading-Anwendungen verwendet werden kann.

Weitere Einzelheiten finden Sie in diesem Artikel:

https://www.geeksforgeeks.org/java-singleton-design-pattern-practices-examples/