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”.
GO TO FULL VERSION