CodeGym /Kursy /JAVA 25 SELF /Deadlock: przyczyny, przykłady, eliminacja

Deadlock: przyczyny, przykłady, eliminacja

JAVA 25 SELF
Poziom 53, Lekcja 0
Dostępny

1. Zagłębiamy się w deadlock

Deadlock („wzajemna blokada”) — to sytuacja, gdy dwa lub więcej wątków czeka na siebie w nieskończoność: każdy trzyma jakiś zasób i próbuje uzyskać inny, już zajęty przez sąsiedni wątek. W efekcie nikt nie może kontynuować pracy i program „zawiesza się”. To jak dwa samochody na wąskim moście ustawione zderzak w zderzak: dopóki jeden nie cofnie — nikt nie przejedzie.

W Javie deadlock to nie wyjątek (Exception), lecz „zawieszenie” programu. Wątki się nie kończą i nie wywalają błędu, tylko czekają na siebie w nieskończoność. Dlatego takie błędy są zdradliwe: ujawniają się tylko „w określonych okolicznościach”.

Cztery warunki powstania deadlocku

  • 1. Wzajemne wykluczanie (Mutual Exclusion)
    Zasób może być jednocześnie przejęty tylko przez jeden wątek (np. obiekt-monitor, plik).
  • 2. Utrzymywanie i oczekiwanie (Hold and Wait)
    Wątek trzyma jeden zasób i próbuje uzyskać drugi, nie zwalniając pierwszego.
  • 3. Brak wywłaszczenia (No Preemption)
    Zasobu nie można „odebrać” wątkowi: tylko sam wątek może go zwolnić.
  • 4. Cykliczne oczekiwanie (Circular Wait)
    Istnieje zamknięty łańcuch, w którym każdy wątek czeka na zasób trzymany przez następny w łańcuchu.

Deadlock jest możliwy tylko wtedy, gdy WSZYSTKIE te warunki są spełnione jednocześnie. Wystarczy naruszyć choć jeden — i wzajemna blokada staje się niemożliwa.

2. Przykład kodu z deadlockiem

Schemat

  • Są dwa zasoby: lock1 i lock2 (zwykłe obiekty).
  • Wątek A najpierw przejmuje lock1, potem próbuje uzyskać lock2.
  • Wątek B najpierw przejmuje lock2, potem próbuje uzyskać lock1.

Przykład (nie rób tego u siebie!)

public class DeadlockDemo {
    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

    public static void main(String[] args) {
        // Wątek 1
        Thread thread1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Wątek 1: przejął lock1");
                try { Thread.sleep(100); } catch (InterruptedException ignored) {}
                System.out.println("Wątek 1: próbuje przejąć lock2");
                synchronized (lock2) {
                    System.out.println("Wątek 1: przejął lock2");
                }
            }
        });

        // Wątek 2
        Thread thread2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Wątek 2: przejął lock2");
                try { Thread.sleep(100); } catch (InterruptedException ignored) {}
                System.out.println("Wątek 2: próbuje przejąć lock1");
                synchronized (lock1) {
                    System.out.println("Wątek 2: przejął lock1");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

Co się stanie po uruchomieniu?

  • Wątek 1 przejmuje lock1, wątek 2 — lock2.
  • Oba „zasypiają” na 100 ms, zdążając przejąć pierwszą blokadę.
  • Następnie każdy próbuje przejąć drugą blokadę, która jest już trzymana przez drugi wątek.
  • Oba wątki czekają na siebie bez końca — powstał deadlock.

W konsoli zobaczysz:

Wątek 1: przejął lock1
Wątek 2: przejął lock2
Wątek 1: próbuje przejąć lock2
Wątek 2: próbuje przejąć lock1

Dlaczego powstaje deadlock? Szczegółowa analiza

  • Wzajemne wykluczanie: każda blokada może być trzymana tylko przez jeden wątek.
  • Utrzymywanie i oczekiwanie: Wątek 1 trzyma lock1 i czeka na lock2; Wątek 2 trzyma lock2 i czeka na lock1.
  • Brak wywłaszczenia: nikt nie może „wyrwać” blokady z zewnątrz — tylko wyjść z bloku synchronized.
  • Cykliczne oczekiwanie: oczekiwanie zamknęło się w pętli między dwoma wątkami.

3. Jak uniknąć i zapobiegać deadlockowi

Przejmowanie zasobów w tej samej kolejności

Główna zasada: jeśli wiele wątków musi przejmować wiele zasobów — rób to zawsze w tej samej kolejności. Na przykład: najpierw lock1, potem lock2 — we wszystkich miejscach w kodzie.

public void doSomething() {
    Object firstLock = lock1;
    Object secondLock = lock2; // jednolita kolejność "lock1 -> lock2"
    synchronized (firstLock) {
        synchronized (secondLock) {
            // Praca z obiema zasobami
        }
    }
}

Przy jednolitej kolejności cykliczne oczekiwanie jest niemożliwe — warunek deadlocku zostaje naruszony.

Użycie tryLock z limitem czasu (ReentrantLock)

Gdy z góry nie wiadomo, jakie zasoby będą potrzebne, używaj ReentrantLock i metody tryLock, aby nie czekać w nieskończoność.

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

public class TryLockDemo {
    private static final ReentrantLock lock1 = new ReentrantLock();
    private static final ReentrantLock lock2 = new ReentrantLock();

    public void doWork() {
        try {
            if (lock1.tryLock(100, TimeUnit.MILLISECONDS)) {
                try {
                    if (lock2.tryLock(100, TimeUnit.MILLISECONDS)) {
                        try {
                            // Sekcja krytyczna
                        } finally {
                            lock2.unlock();
                        }
                    } else {
                        System.out.println("Nie udało się przejąć lock2, wycofujemy się");
                    }
                } finally {
                    lock1.unlock();
                }
            } else {
                System.out.println("Nie udało się przejąć lock1, wycofujemy się");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

Plus: można wycofać operację i spróbować później. Minus: kod jest bardziej złożony, ale deadlock jest wykluczony.

Minimalizuj czas trzymania blokad

Trzymaj blokadę jak najkrócej. Wewnątrz synchronized/lock rób tylko to, co konieczne; wszystko pozostałe wynoś poza sekcję krytyczną.

Unikaj zagnieżdżonych blokad

Im mniej zagnieżdżonych synchronized/lock, tym mniejsze ryzyko wzajemnej blokady. Jeśli to możliwe — używaj jednej blokady dla powiązanych zasobów.

Używaj gotowych struktur thread-safe

Biblioteka standardowa rozwiązała już wiele problemów: kolekcje takie jak ConcurrentHashMap i inne klasy z java.util.concurrent minimalizują ryzyko deadlocku i upraszczają kod.

4. Diagnostyka deadlocku

Thread Dump i jstack

Thread Dump — zrzut stanu wszystkich wątków w JVM.

Z konsoli:

jstack <pid>

Gdzie <pid> to identyfikator procesu Java (można poznać przez jps).

W IDE zwykle jest przycisk „Thread Dump” na pasku debugowania.

W zrzucie szukaj:

  • Stanów BLOCKED lub WAITING.
  • Komunikatów w rodzaju waiting to lock ... i locked ....
  • Frazy JVM: "Found one Java-level deadlock:" — gdy wykryto wzajemną blokadę.

Przykład fragmentu zrzutu:

"Thread-1":
  waiting to lock monitor 0x000000001e4000, (object 0x7f8a5c00, a java.lang.Object),
  which is held by "Thread-2"
"Thread-2":
  waiting to lock monitor 0x000000001e3000, (object 0x7f8a5c10, a java.lang.Object),
  which is held by "Thread-1"

To właśnie deadlock: wątki „trzymają” się nawzajem.

VisualVM i inne narzędzia

  • VisualVM — darmowe narzędzie do analizy wątków i wykrywania deadlocków.
  • Java Mission Control / Flight Recorder — zaawansowany monitoring i profilowanie.

W VisualVM można zobaczyć drzewo wątków, ich stany i otrzymać powiadomienie o wzajemnej blokadzie.

Tabela: „Jak nie wpaść w deadlock”

Przyczyna deadlocku Jak uniknąć
Przejmowanie zasobów w różnej kolejności Zawsze trzymać się jednej kolejności przejmowania zasobów
Zagnieżdżone synchronized Minimalizować zagnieżdżenie, w miarę możliwości używać jednej blokady
Długie trzymanie blokady Ograniczyć pracę wewnątrz sekcji krytycznej
Używanie wielu blokad jednocześnie Stosować tryLock z limitem czasu i potrafić się wycofać
Kolekcje nie thread-safe Używać kolekcji współbieżnych (ConcurrentHashMap itp.)

5. Typowe błędy przy pracy z deadlockiem

Błąd nr 1: Przejmowanie zasobów w różnej kolejności. Najczęstsza przyczyna — różne wątki biorą blokady w różnej kolejności. Nawet jeśli „tak jest szybciej”, trzymaj się jednej kolejności — w przeciwnym razie cykliczne oczekiwanie jest gwarantowane.

Błąd nr 2: Zagnieżdżone synchronized bez potrzeby. Zbędne zagnieżdżenie zwiększa ryzyko wzajemnej blokady i komplikuje kod. Uprość model blokad.

Błąd nr 3: Ignorowanie tryLock i limitów czasu. Blokowanie przez synchronized zmusi wątek do czekania bez końca. Jeśli nie ma pewności, używaj tryLock z limitem czasu oraz logiki wycofania.

Błąd nr 4: Długie wykonywanie kodu wewnątrz blokady. Żądania sieciowe, operacje I/O i ciężkie obliczenia pod blokadą mocno zwiększają ryzyko problemów. Wynoś je poza sekcję krytyczną.

Błąd nr 5: Brak analizy Thread Dump. Thread Dump to twój najlepszy przyjaciel przy szukaniu wzajemnych blokad. Używaj jstack i analizuj stany BLOCKED/WAITING, łańcuchy „holding/waiting to lock”.

1
Zadanie
JAVA 25 SELF, poziom 53, lekcja 0
Niedostępne
Przekazywanie pałeczki sztafetowej między robotami: Niebezpieczeństwo zakleszczenia 🤖
Przekazywanie pałeczki sztafetowej między robotami: Niebezpieczeństwo zakleszczenia 🤖
1
Zadanie
JAVA 25 SELF, poziom 53, lekcja 0
Niedostępne
Uratowanie przed zakleszczeniem: Sprytni inżynierowie z timeoutem 🛠️
Uratowanie przed zakleszczeniem: Sprytni inżynierowie z timeoutem 🛠️
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION