Deadlock in Java Beispiel

Deadlocks in Java: Ursachen, Beispiele und Strategien zur Vermeidung

Einleitung

Ein Deadlock, auch als Verklemmung bekannt, ist eine Situation, in der mehrere Threads auf Ressourcen warten, die voneinander belegt sind. Diese Situation verhindert die weitere Ausführung der Threads und führt zu einem Blockadezustand des gesamten Programms. Solche Deadlocks sind eine typische Herausforderung in der nebenläufigen Programmierung und können zu Ineffizienz und Frustration führen.

Die Entstehung von Deadlocks

Deadlocks treten im Normalfall auf, wenn diese vier Bedingungen gleichzeitig gegeben sind:

• Gegenseitiger Ausschluss: Eine Ressource kann immer nur von einem einzigen Thread zur selben Zeit genutzt werden.
• Warten und Halten: Ein Thread wartet auf eine Ressource, die von einem anderen Thread aktuell gehalten wird.
• Keine Vorbelegung: Ressourcen werden erst dann von einem Thread angefordert, wenn sie tatsächlich benötigt werden.
• Zirkuläre Abhängigkeit: Es entsteht eine Kette von Threads, in der jeder Thread auf eine Ressource wartet, die von einem anderen Thread aus der Kette gehalten wird, wodurch ein Kreislauf entsteht.

Deadlock-Beispiele in Java

Beispiel 1: Banktransaktion

Betrachten wir ein Szenario, in dem Gelder zwischen zwei Bankkonten transferiert werden:


class Bank {
private int konto1;
private int konto2;

public synchronized void ueberweisen(int betrag) {
while (konto1 < betrag) {
try {
wait();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
konto1 -= betrag;
konto2 += betrag;
notifyAll();
}
}

class Person1 extends Thread {
private Bank bank;
private int betrag;

public Person1(Bank bank, int betrag) {
this.bank = bank;
this.betrag = betrag;
}

public void run() {
bank.ueberweisen(betrag);
}
}

class Person2 extends Thread {
private Bank bank;
private int betrag;

public Person2(Bank bank, int betrag) {
this.bank = bank;
this.betrag = betrag;
}

public void run() {
bank.ueberweisen(betrag);
}
}


In diesem Beispiel kann ein Deadlock entstehen, wenn beide Threads gleichzeitig versuchen, Geld zu überweisen. Thread 1 versucht, den Zugriff auf konto1 zu synchronisieren, um eine Abbuchung vorzunehmen, während Thread 2 versucht, konto2 für eine Einzahlung zu sperren. Wenn nun Thread 1 zuerst den Zugriff auf konto1 erhält, während Thread 2 auf konto2 wartet und Thread 1 gleichzeitig auf konto2 wartet, resultiert ein Deadlock.

Beispiel 2: Das Problem der speisenden Philosophen

Das klassische Philosophenproblem veranschaulicht einen Deadlock sehr gut. Eine Gruppe von Philosophen denkt und isst abwechselnd. Zum Essen benötigen sie zwei Gabeln.


class Philosoph implements Runnable {
private int id;
private Tisch tisch;

public Philosoph(int id, Tisch tisch) {
this.id = id;
this.tisch = tisch;
}

public void run() {
while (true) {
denken();
tisch.nimmGabel(id, id);
essen();
tisch.legeGabel(id, id);
}
}

private void denken() {
// Nachdenken
}

private void essen() {
// Essen
}
}

class Tisch {
private boolean[] gabeln;

public Tisch(int anzahlPhilosophen) {
gabeln = new boolean[anzahlPhilosophen];
}

public synchronized void nimmGabel(int linkeGabel, int rechteGabel) {
while (gabeln[linkeGabel] || gabeln[rechteGabel]) {
try {
wait();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
gabeln[linkeGabel] = gabeln[rechteGabel] = true;
}

public synchronized void legeGabel(int linkeGabel, int rechteGabel) {
gabeln[linkeGabel] = gabeln[rechteGabel] = false;
notifyAll();
}
}


Hier entsteht ein Deadlock, wenn alle Philosophen gleichzeitig nach der linken Gabel greifen. Jeder Philosoph wartet auf die Gabel des rechten Nachbarn, der wiederum auf seine wartet, wodurch ein Kreis entsteht.

Strategien zur Deadlock-Behandlung

Es gibt verschiedene Ansätze zur Bewältigung von Deadlocks:

• Deadlock-Prävention: Hier wird dafür gesorgt, dass mindestens eine der vier oben genannten Bedingungen für einen Deadlock nicht zutrifft.
• Deadlock-Erkennung: Das System erkennt aktiv Deadlocks, wenn sie auftreten, und ergreift Maßnahmen, um sie aufzulösen.
• Deadlock-Auflösung: Hier werden Threads beendet oder Ressourcen freigegeben, um den Deadlock aufzulösen.

Fazit

Deadlocks stellen eine ernsthafte Herausforderung in der parallelen Programmierung dar und können zu Performance-Problemen und Frustration führen. Das Verständnis der Ursachen und Lösungsansätze ist entscheidend, um robustere und zuverlässigere Anwendungen zu entwickeln.

Häufig gestellte Fragen (FAQs)

1. Was genau ist ein Deadlock?	Ein Deadlock ist eine Situation, in der zwei oder mehrere Threads blockiert sind, weil jeder auf eine Ressource wartet, die von einem anderen Thread gehalten wird.
2. Welche Bedingungen müssen für einen Deadlock gleichzeitig erfüllt sein?	Die vier Bedingungen sind: Gegenseitiger Ausschluss, Warten und Halten, Keine Vorbelegung, Zirkuläre Abhängigkeit.
3. Wie lassen sich Deadlocks verhindern?	Mögliche Strategien zur Deadlock-Prävention sind das Sortieren der Locks, um eine Reihenfolge einzuhalten, oder der Einsatz von Timeouts bei Sperranforderungen.
4. Wie werden Deadlocks erkannt?	Dies geschieht durch den Einsatz von Deadlock-Detektoren oder Zeitstempeltechniken.
5. Wie können Deadlocks wieder aufgehoben werden?	In der Regel durch das Beenden von Threads oder das Freigeben der belegten Ressourcen.
6. Was ist das Problem der speisenden Philosophen?	Es ist ein bekanntes Beispiel für einen Deadlock, das veranschaulicht, wie mehrere Threads durch den gleichzeitigen Zugriff auf Ressourcen blockieren können.
7. Wie lässt sich das Philosophenproblem lösen?	Lösungsansätze sind beispielsweise die Aufhebung der Warteordnung oder die Verwendung eines zentralen Schedulers.
8. Warum ist es wichtig, Deadlocks in Java zu verstehen?	Deadlocks können in Java zu Leistungsproblemen, Fehlern und Programmabstürzen führen. Ein grundlegendes Verständnis von Deadlocks ist entscheidend, um zuverlässige und robuste Anwendungen zu entwickeln.