Vermeiden Sie synchronized(this) in Java?

Question

Wann immer auf SO eine Frage zur Java-Synchronisierung auftaucht, sind einige Leute sehr eifrig dabei, darauf hinzuweisen, dass synchronized(this) sollte vermieden werden. Stattdessen sei eine Sperre für eine private Referenz vorzuziehen.

Einige der genannten Gründe sind:

• einige böser Code kann Ihr Schloss stehlen (sehr beliebt, es gibt auch eine "zufällige" Variante)
• alle synchronisierten Methoden innerhalb derselben Klasse verwenden genau dieselbe Sperre, was den Durchsatz verringert
• Sie geben (unnötigerweise) zu viele Informationen preis.

Andere Leute, darunter auch ich, argumentieren, dass synchronized(this) ist ein Idiom, das häufig verwendet wird (auch in Java-Bibliotheken), sicher ist und gut verstanden wird. Es sollte nicht vermieden werden, weil Sie einen Fehler haben und keine Ahnung haben, was in Ihrem Multithreading-Programm vor sich geht. Mit anderen Worten: Wenn es anwendbar ist, dann verwenden Sie es.

Ich bin daran interessiert, einige Beispiele aus der Praxis zu sehen (kein Foobar-Zeug), bei denen die Vermeidung einer Sperre auf this ist vorzuziehen, wenn synchronized(this) würde die Aufgabe ebenfalls erfüllen.

Deshalb: sollten Sie immer vermeiden synchronized(this) und sie durch eine Sperre für eine private Referenz ersetzen?

---

Einige weitere Informationen (aktualisiert, sobald Antworten gegeben werden):

• es geht um die Synchronisierung von Instanzen
• sowohl implizit ( synchronized Methoden) und explizite Form der synchronized(this) werden als
• wenn Sie Bloch oder andere Autoritäten zu diesem Thema zitieren, lassen Sie nicht die Teile weg, die Ihnen nicht gefallen (z.B. Effektives Java, Artikel über Thread-Sicherheit: Normalerweise ist es die Sperre der Instanz selbst, aber es gibt Ausnahmen).
• wenn Sie eine andere Granularität für Ihre Sperren benötigen als synchronized(this) bietet, dann synchronized(this) ist nicht anwendbar, also ist das nicht das Problem

Answer 1

Ich werde auf jeden Punkt einzeln eingehen.

1. Ein böser Code kann Ihr Schloss stehlen (sehr beliebt, hat auch einen "zufällige" Variante)

   Ich mache mir mehr Sorgen über versehentlich . Es läuft darauf hinaus, dass diese Verwendung von this ist Teil der exponierten Schnittstelle Ihrer Klasse und sollte dokumentiert werden. Manchmal ist es erwünscht, dass anderer Code Ihre Sperre verwenden kann. Dies gilt für Dinge wie Collections.synchronizedMap (siehe das Javadoc).

2. Alle synchronisierten Methoden innerhalb der gleichen Klasse verwenden genau die gleiche Sperre, was den Durchsatz verringert

   Dies ist eine allzu vereinfachte Sichtweise, denn es reicht aus, die synchronized(this) wird das Problem nicht lösen. Die richtige Synchronisierung für den Durchsatz erfordert mehr Überlegung.

3. Sie geben (unnötigerweise) zu viele Informationen preis

   Dies ist eine Variante von Nr. 1. Verwendung von synchronized(this) ist Teil Ihrer Schnittstelle. Wenn Sie das nicht wollen/brauchen, tun Sie es nicht.

Answer 2

Nun, zunächst einmal sollte darauf hingewiesen werden, dass:

public void blah() {
  synchronized (this) {
    // do stuff
  }
}

ist semantisch äquivalent zu:

public synchronized void blah() {
  // do stuff
}

was ein Grund dafür ist, nicht die synchronized(this) . Man könnte argumentieren, dass man Dinge rund um das Haus tun kann. synchronized(this) blockieren. Der übliche Grund ist der Versuch, die synchronisierte Prüfung überhaupt zu vermeiden, was zu allen möglichen Gleichzeitigkeitsproblemen führt, insbesondere die Problem der doppelten Verriegelung was nur zeigt, wie schwierig es sein kann, eine relativ einfache Prüfung thread-sicher zu machen.

Eine private Sperre ist ein Verteidigungsmechanismus, der nie eine schlechte Idee ist.

Außerdem können, wie Sie bereits angedeutet haben, private Sperren die Granularität steuern. Ein Satz von Operationen an einem Objekt kann völlig unabhängig von einem anderen sein, aber synchronized(this) schließt den Zugriff auf alle von ihnen aus.

synchronized(this) gibt Ihnen wirklich nichts.

Answer 3

Wenn Sie synchronized(this) verwenden, verwenden Sie die Klasseninstanz selbst als Sperre. Das bedeutet, dass während die Sperre von Gewinde 1 die Gewinde 2 warten sollte.

Nehmen wir den folgenden Code an:

public void method1() {
    // do something ...
    synchronized(this) {
        a ++;      
    }
    // ................
}

public void method2() {
    // do something ...
    synchronized(this) {
        b ++;      
    }
    // ................
}

Methode 1: Änderung der Variablen a und Methode 2 die Änderung der Variablen b sollte die gleichzeitige Änderung derselben Variablen durch zwei Threads vermieden werden, was auch geschieht. ABER während Gewinde1 Ändern von a y Thema2 Ändern von b es kann ohne jede Race Condition durchgeführt werden.

Leider lässt der obige Code dies nicht zu, da wir denselben Verweis für eine Sperre verwenden. Das bedeutet, dass Threads, auch wenn sie sich nicht in einer Race Condition befinden, warten müssen, und der Code opfert offensichtlich die Gleichzeitigkeit des Programms.

Die Lösung ist die Verwendung von 2 verschiedene Schlösser für zwei verschiedene Variablen:

public class Test {

    private Object lockA = new Object();
    private Object lockB = new Object();

    public void method1() {
        // do something ...
        synchronized(lockA) {
            a ++;      
        }
        // ................
    }

    public void method2() {
        // do something ...
        synchronized(lockB) {
            b ++;      
        }
        // ................
    }

}

Das obige Beispiel verwendet feiner abgestufte Sperren (2 Sperren statt einer ( lockA und sperrenB für Variablen a y b bzw.) und ermöglicht dadurch eine bessere Gleichzeitigkeit, andererseits wurde es komplexer als das erste Beispiel ...

Answer 4

Ich stimme zwar zu, dass man sich nicht blindlings an dogmatische Regeln halten sollte, aber erscheint Ihnen das Szenario des "Sperrdiebstahls" so exzentrisch? Ein Thread könnte in der Tat die Sperre für Ihr Objekt "von außen" erwerben ( synchronized(theObject) {...} ), wodurch andere Threads, die auf synchronisierte Instanzmethoden warten, blockiert werden.

Wenn Sie nicht an bösartigen Code glauben, bedenken Sie, dass dieser Code von Dritten stammen könnte (z. B. wenn Sie eine Art Anwendungsserver entwickeln).

Die "zufällige" Version scheint weniger wahrscheinlich, aber wie man so schön sagt: "Wenn man etwas idiotensicher macht, erfindet man einen besseren Idioten".

Ich stimme also mit der Denkweise überein, dass es davon abhängt, was die Klasse tut.

---

Edit nach den ersten 3 Kommentaren von eljenso:

Ich habe das Problem des Diebstahls von Schlössern noch nie erlebt, aber hier ist ein imaginäres Szenario:

Angenommen, Ihr System ist ein Servlet-Container, und das Objekt, das wir betrachten, ist die ServletContext Umsetzung. Seine getAttribute Methode muss thread-sicher sein, da Kontextattribute gemeinsam genutzte Daten sind; daher deklarieren Sie sie als synchronized . Stellen wir uns außerdem vor, dass Sie einen öffentlichen Hosting-Dienst auf der Grundlage Ihrer Container-Implementierung anbieten.

Ich bin Ihr Kunde und setze mein "gutes" Servlet auf Ihrer Website ein. Es kommt vor, dass mein Code einen Aufruf enthält an getAttribute .

Ein Hacker, getarnt als ein anderer Kunde, setzt sein bösartiges Servlet auf Ihrer Website ein. Es enthält den folgenden Code in der init Methode:

synchronized (this.getServletConfig().getServletContext()) {
   while (true) {}
}

Unter der Annahme, dass wir uns denselben Servlet-Kontext teilen (was nach der Spezifikation zulässig ist, solange sich die beiden Servlets auf demselben virtuellen Host befinden), kann mein Aufruf auf getAttribute ist für immer gesperrt. Der Hacker hat einen DoS auf mein Servlet erreicht.

Dieser Angriff ist nicht möglich, wenn getAttribute wird mit einer privaten Sperre synchronisiert, da Code von Drittanbietern diese Sperre nicht erwerben kann.

Ich gebe zu, dass das Beispiel konstruiert ist und eine zu einfache Sichtweise auf die Funktionsweise eines Servlet-Containers darstellt, aber IMHO beweist es den Punkt.

Ich würde also meine Design-Entscheidung auf der Grundlage von Sicherheitsüberlegungen treffen: Werde ich die vollständige Kontrolle über den Code haben, der Zugriff auf die Instanzen hat? Was wäre die Konsequenz, wenn ein Thread eine Instanz auf unbestimmte Zeit sperren würde?

Answer 5

Das hängt von der jeweiligen Situation ab.
Wenn es nur eine oder mehrere geteilte Einheiten gibt.

Siehe vollständiges Arbeitsbeispiel hier

Eine kleine Einführung.

Threads und gemeinsam nutzbare Einheiten
Es ist möglich, dass mehrere Threads auf dieselbe Einheit zugreifen, z. B. mehrere connectionThreads, die sich eine einzige messageQueue teilen. Da die Threads gleichzeitig ablaufen, besteht die Möglichkeit, dass die Daten eines Threads von einem anderen überschrieben werden, was zu einem Durcheinander führen kann.
Wir brauchen also eine Möglichkeit, um sicherzustellen, dass nur jeweils ein Thread auf eine gemeinsam nutzbare Entität zugreifen kann. (CONCURRENCY).

Synchronisierter Block
synchronized()-Block ist eine Möglichkeit, den gleichzeitigen Zugriff auf eine gemeinsam nutzbare Entität zu gewährleisten.
Zunächst eine kleine Analogie
Angenommen, es gibt zwei Personen P1, P2 (Fäden), ein Waschbecken (gemeinsam nutzbare Einheit) in einem Waschraum und eine Tür (Schloss).
Jetzt wollen wir, dass jeweils eine Person das Waschbecken benutzt.
Ein Ansatz besteht darin, die Tür durch P1 zu verschließen, wenn die Tür verschlossen ist, wartet P2, bis P1 seine Arbeit beendet hat
P1 entriegelt die Tür
dann kann nur p1 das Waschbecken benutzen.

Syntax.

synchronized(this)
{
  SHARED_ENTITY.....
}

"this" stellt die der Klasse zugeordnete Sperre zur Verfügung (Java-Entwickler haben die Klasse Object so konzipiert, dass jedes Objekt als Monitor arbeiten kann). Der obige Ansatz funktioniert gut, wenn es nur eine gemeinsame Entität und mehrere Threads gibt (1: N).
N gemeinsam nutzbare Einheiten - M Threads
Stellen Sie sich nun eine Situation vor, in der es in einem Waschraum zwei Waschbecken und nur eine Tür gibt. Wenn wir den vorherigen Ansatz verwenden, kann nur p1 jeweils ein Waschbecken benutzen, während p2 draußen wartet. Das ist eine Verschwendung von Ressourcen, da niemand B2 (Waschbecken) benutzt.
Ein klügerer Ansatz wäre es, einen kleineren Raum im Waschraum zu schaffen und ihnen eine Tür pro Waschbecken zu geben. Auf diese Weise kann P1 Zugang zu B1 und P2 Zugang zu B2 haben und umgekehrt.

washbasin1;  
washbasin2;

Object lock1=new Object();
Object lock2=new Object();

  synchronized(lock1)
  {
    washbasin1;
  }

  synchronized(lock2)
  {
    washbasin2;
  }

Siehe mehr auf Threads ----> hier