Synchronisation: Verteilter Zugriff auf gemeinsame Ressourcen

Motivation: Verteilter Zugriff auf gemeinsame Ressourcen

public class Teaser implements Runnable {
    private int val = 0;

    public static void main(String... args) {
        Teaser x = new Teaser();
        new Thread(x).start();
        new Thread(x).start();
    }

    private void incrVal() {
        ++val;
        System.out.println(Thread.currentThread().getId() + ": " + val);
    }

    public void run() {
        IntStream.range(0, 5).forEach(i -> incrVal());
    }
}

Zugriff auf gemeinsame Ressourcen: Mehrseitige Synchronisierung

synchronized (<Object reference>) {
    <statements (synchronized)>
}

=> "Mehrseitige Synchronisierung"

Fallunterscheidung: Thread T1 führt synchronized-Anweisung aus:

• Sperre im Sperr-Objekt nicht gesetzt:
  1. T1 setzt Sperre beim Eintritt,
  2. führt den Block aus, und
  3. löst Sperre beim Verlassen
• Sperre durch T1 gesetzt:
  1. T1 führt den Block aus, und
  2. löst Sperre beim Verlassen nicht
• Sperre durch T2 gesetzt: => T1 wird blockiert, bis T2 die Sperre löst

Anmerkung: Das für die Synchronisierung genutzte Objekt nennt man "Wächter-Objekt" oder auch "Sperr-Objekt" oder auch "Synchronisations-Objekt".

Damit könnte man den relevanten Teil der Methode incrVal() beispielsweise in einen geschützten Bereich einschließen und als Sperr-Objekt das eigene Objekt (this) einsetzen:

    private void incrVal() {
        synchronized (this) { ++val; }
    }

Synchronisierte Methoden

void f() {
    synchronized (this) {
        ...
    }
}

synchronized void f() {
    ...
}

Kurzschreibweise: Man spart das separate Wächter-Objekt und synchronisiert auf sich selbst ...

Die Methode incrVal() könnte entsprechend so umgeschrieben werden:

    private synchronized void incrVal() {
        ++val;
    }

Probleme bei der (mehrseitigen) Synchronisierung: Deadlocks

public class Deadlock {
    private final String name;

    public synchronized String getName() { return name; }
    public synchronized void foo(Deadlock other) {
        System.out.format("%s: %s.foo() \n", Thread.currentThread().getName(), name);
        System.out.format("%s: %s.name()\n", Thread.currentThread().getName(), other.getName());
    }

    public static void main(String... args) {
        final Deadlock a = new Deadlock("a");
        final Deadlock b = new Deadlock("b");

        new Thread(() -> a.foo(b)).start();
        new Thread(() -> b.foo(a)).start();
    }
}

Viel hilft hier nicht viel! Durch zu großzügige mehrseitige Synchronisierung kann es passieren, dass Threads gegenseitig aufeinander warten: Thread A belegt eine Ressource, die ein anderer Thread B haben möchte und Thread B belegt eine Ressource, die A gerne bekommen würde. Da es dann nicht weitergeht, nennt man diese Situation auch "Deadlock" ("Verklemmung").

Im Beispiel ruft der erste Thread für das Objekt a die foo()-Methode auf und holt sich damit den Lock auf a. Um die Methode beenden zu können, muss noch die getName()-Methode vom Objekt b durch diesen ersten Thread aufgerufen werden. Dafür muss der erste Thread den Lock auf b bekommen.

Dummerweise hat parallel der zweite Thread auf dem Objekt b die foo()-Methode aufgerufen und sich damit den Lock auf b geholt. Damit muss der erste Thread so lange warten, bis der zweite Thread den Lock auf b freigibt.

Das wird allerdings nicht passieren, da der zweite Thread zur Beendigung der foo()-Methode noch getName() auf a ausführen muss und dazu den Lock auf b holen, den aber aktuell der erste Thread hält.

Und schon geht's nicht mehr weiter :-)

Warten auf andere Threads: Einseitige Synchronisierung

Problem

• Thread T1 wartet auf Arbeitsergebnis von T2
• T2 ist noch nicht fertig

Mögliche Lösungen

1. Aktives Warten (Polling): Permanente Abfrage
   • Kostet unnötig Rechenzeit
2. Schlafen mit Thread.sleep()
   • Etwas besser; aber wie lange soll man idealerweise schlafen?
3. Warten mit T2.join()
   • Macht nur Sinn, wenn T1 auf das Ende von T2 wartet
4. Einseitige Synchronisierung mit wait() und notify()
   • Das ist DIE Lösung für das Problem :)

Einseitige Synchronisierung mit wait und notify

• wait: Warten auf Erfüllung einer Bedingung (Thread blockiert):

  synchronized (obj) {    // Geschützten Bereich betreten
      while (!condition) {
          try {
              obj.wait(); // Thread wird blockiert
          } catch (InterruptedException e) {}
      }
      ...     // Condition erfüllt: Tue Deine Arbeit
  }

  => Bedingung nach Rückkehr von wait erneut prüfen!

Eigenschaften von wait

• Thread ruft auf Synchronisations-Objekt die Methode wait auf
• Prozessor wird entzogen, Thread blockiert
• Thread wird in interne Warteschlange des Synchronisations-Objekts eingetragen
• Sperre auf Synchronisations-Objekt wird freigegeben

=> Geht nur innerhalb der synchronized-Anweisung für das Synchronisations-Objekt!

Einseitige Synchronisierung mit wait und notify (cnt.)

• notify: Aufwecken von wartenden (blockierten) Threads:

  synchronized (obj) {
      obj.notify();       // einen Thread "in" obj aufwecken
      obj.notifyAll();    // alle Threads "in" obj wecken
  }

Eigenschaften von notify bzw. notifyAll

• Thread ruft auf einem Synchronisations-Objekt die Methode notify oder notifyAll auf
• Falls Thread(s) in Warteschlange des Objekts vorhanden, dann
  • notify: Ein zufälliger Thread wird aus Warteschlange entfernt und in den Zustand "ausführungsbereit" versetzt
  • notifyAll: Alle Threads werden aus Warteschlange entfernt und in den Zustand "ausführungsbereit" versetzt

=> Geht nur innerhalb der synchronized-Anweisung für das Synchronisations-Objekt!

Wrap-Up

Synchronisierungsbedarf bei verteiltem Zugriff auf gemeinsame Ressourcen:

• Vorsicht mit konkurrierendem Ressourcenzugriff: Synchronisieren mit synchronized => Mehrseitige Synchronisierung

• Warten auf Ereignisse mit wait und notify/notifyAll => Einseitige Synchronisierung