Was ist eine Deadlock -Situation in Java und wie kann sie verhindert werden?

Deadlock tritt in Java auf, wenn zwei oder mehr Fäden dauerhaft blockieren und auf die voneinander gehaltenen Ressourcen des anderen warten und eine kreisförmige Abhängigkeit bilden. 1. Vermeiden Sie verschachtelte Schlösser, erwerben Sie immer Schlösser in einer konsistenten Reihenfolge und verhindern Sie das Warten von Schleifen. 2. Verwenden Sie Trylock () mit Timeout, um den Thread aktiv zu beenden, wenn er das Schloss nicht erwerben kann. 3.. Reduzieren Sie den Umfang des Schlosses und geben Sie der Verwendung von lock-freien Strukturen wie Concurrenthashmap und Atomicinder Priorität. 4. Verwenden Sie Tools wie JStack und VisualVM, um Deadlocks zu erkennen, und kombinieren Sie die Tools für die Einheitstests und statische Analyse, um potenzielle Probleme zu entdecken. 5. Refactor den Code, um nicht gleichzeitig mehrere Schlösser zu halten, z. Durch die Befolgung dieser Strategien können Deadlocks effektiv verhindert werden und die Stabilität von Multi-Thread-Programmen sichergestellt werden.

Ein Deadlock in Java tritt auf, wenn zwei oder mehr Fäden für immer blockiert sind, wobei jeder auf eine Ressource wartet, die ein anderer Thread hält und einen Abhängigkeitszyklus erstellt. Dies geschieht in der Regel in Multithread -Programmen, wenn Threads Sperrungen für mehrere Objekte erfassen und am Ende darauf warten, dass sich diese Schlösser freigeben.

Wie Deadlock passiert - ein einfaches Beispiel

Stellen Sie sich zwei Threads vor, Thread A und Thread B sowie zwei Objekte, OBJ1 und OBJ2:

• Faden A hält eine Sperre für OBJ1 und möchte eine Sperre für OBJ2 erwerben.
• Thread B hält eine Sperre für OBJ2 und möchte eine Schloss für OBJ1 erwerben.

Jetzt warten beide Threads darauf, dass einander das Schloss freigibt - und auch nicht. Dies ist ein klassischer Deadlock.

Hier ist ein Code -Snippet, der zu Deadlock führen kann:

 öffentliche Klasse Deadlockexample {
    statisches Objekt obj1 = neues Objekt ();
    statisches Objekt obj2 = neues Objekt ();

    public static void main (String [] args) {
        Thread t1 = neuer Thread (() -> {
            synchronisiert (obj1) {
                System.out.println ("Thread 1: Halten Sie die Sperre für OBJ1 ...");
                try {thread.sleep (100); } catch (InterruptedException e) {}
                System.out.println ("Thread 1: Warten auf OBJ2 ...");
                synchronisiert (obj2) {
                    System.out.println ("Thread 1: erworbener obj2");
                }
            }
        });

        Thread t2 = neuer Thread (() -> {
            synchronisiert (obj2) {
                System.out.println ("Thread 2: Halten des Schlosses für OBJ2 ...");
                try {thread.sleep (100); } catch (InterruptedException e) {}
                System.out.println ("Thread 2: Warten auf OBJ1 ...");
                synchronisiert (obj1) {
                    System.out.println ("Thread 2: erworbener OBJ1");
                }
            }
        });

        t1.start ();
        t2.Start ();
    }
}

Dieser Code kann auf unbestimmte Zeit hängen - ein Deadlock.

Wie man Deadlock in Java verhindert

Die Verhinderung von Deadlocken beinhaltet eine sorgfältige Gestaltung, wie Fäden Schlösser erwerben und freigeben. Hier sind die Hauptstrategien:

1. Vermeiden Sie verschachtelte Schlösser (Verriegelungsbestellung)

Erwerben Sie immer Schlösser in einer konsistenten, vordefinierten Reihenfolge. Wenn alle Threads mehrere Sperren in derselben Reihenfolge anfordern, können kreisförmige Wartenbedingungen nicht auftreten.

Zum Beispiel:

 // Erwerben Sie immer zuerst OBJ1, dann OBJ2
synchronisiert (obj1) {
    synchronisiert (obj2) {
        // Arbeit machen
    }
}

Wenn jeder Thread dieser Reihenfolge folgt, wird Thread B OBJ2 nicht gehalten, während er auf OBJ1 wartet, wenn Thread A bereits OBJ1 enthält.

2. Verwenden Sie eine Zeitüberschreitung, wenn Sie versuchen, ein Schloss zu erwerben

Verwenden Sie tryLock() von java.util.concurrent.locks.ReentrantLock mit einer Zeitlimit anstelle von synchronized . Dadurch kann ein Faden nach einer bestimmten Zeit aufgeben und den Deadlock -Zyklus durchbrechen.

 Reentrantlock lock1 = neuer Reentrantlock ();
Reentrantlock lock2 = new Reentrantlock ();

// im Thread
if (lock1.rylock (1000, TimeUnit.Milliseconds)) {
    versuchen {
        if (lock2.trylock (1000, TimeUnit.Milliseconds)) {
            versuchen {
                // Arbeit machen
            } Endlich {
                lock2.Unlock ();
            }
        }
    } Endlich {
        lock1.unlock ();
    }
}

Wenn ein Schloss innerhalb des Zeitüberschreiters nicht erworben werden kann, wird der Thread zurückgezogen - und das Warten von unbestimmten Zeiten vermeiden.

3.. Minimieren Sie den Schlossumfang und verwenden Sie lockfreie Strukturen

• Sperren Sie nur den minimalen kritischen Abschnitt.
• Verwenden Sie Concurrent Data Structuren wie ConcurrentHashMap , CopyOnWriteArrayList oder Atomic -Klassen ( AtomicInteger usw.), wenn möglich, um die Notwendigkeit einer expliziten Verriegelung zu verringern.

4. Verwenden Sie statische Analysen und Werkzeuge

• Verwenden Sie Tools wie JStack , JConsole oder VisualVM, um Deadlocks zur Laufzeit zu erkennen.
• JStack kann Thread -Dumps drucken, die zeigen, welche Threads blockiert sind und auf welche Monitore.
• Schreiben Sie Unit -Tests für gleichzeitige Code und verwenden Sie Tools wie Findbugs/Spotbugs, um potenzielle Deadlock -Probleme zu erkennen.

5. Design, um zu vermeiden, mehrere Schlösser zu halten

Wenn möglich, strukturieren Sie Ihren Code, sodass Threads nicht mehrere Sperren gleichzeitig aufbewahren müssen. Zum Beispiel:

• Verwenden Sie Message-Passing-Modelle (z. B. BlockingQueue ) anstelle eines gemeinsamen Zustands.
• Reduzieren Sie gemeinsame veränderliche Daten.

Zusammenfassung

Deadlock ist ein ernstes Problem in Multithread -Java -Anwendungen, kann jedoch mit ordnungsgemäßem Design vermieden werden. Zu den wichtigsten Verhinderungstechniken gehören:

• Immer Schlösser in einer konsistenten Reihenfolge erwerben.
• Verwenden Sie tryLock() mit Timeouts.
• Reduzierung des Umfangs der Schlösser und Vermeidung einer verschachtelten Synchronisation.
• Bevorzugung gleichzeitige Sammlungen und Atomvariablen.
• Überwachung und Prüfung auf Deadlocks während der Entwicklung.

Während Sie das Risiko nicht immer vollständig beseitigen können, machen die Befolgung dieser Praktiken Deadlocks viel weniger wahrscheinlich.

Grundsätzlich geht es um Disziplin, wie Sie den Zugriff auf gemeinsam genutzte Ressourcen verwalten.

Das obige ist der detaillierte Inhalt vonWas ist eine Deadlock -Situation in Java und wie kann sie verhindert werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!