Lekcje

Behawioralny wzorzec „Obserwator”: role Subject i Observer, subskrypcja/wyrejestrowanie przez addObserver/ removeObserver, oraz dystrybucja powiadomień metodą notifyObservers. Omawiamy powiązanie z modelem zdarzeń Javy: button. addActionListener( listener) ; → wywołanie actionPerformed(). Praktyka na przykładach (termometr i klimatyzator, mini‑licznik i lambdy), a także dlaczego java.util.Observable/ Observer są przestarzałe i jakie istnieją nowoczesne podejścia.

W tej lekcji wyjaśniamy, czym jest wątek obsługi zdarzeń UI — EDT w Swing oraz jego odpowiednik JavaFX Application Thread, dlaczego komponenty interfejsu nie są bezpieczne wątkowo i z jakiego powodu okno „zawiesza się” przy ciężkich zadaniach. Pokażemy właściwe techniki: przenoszenie obliczeń do tła przez new Thread(...), aktualizację interfejsu wywołaniami SwingUtilities.invokeLater i Platform.runLater, a także użycie narzędzi wyższego poziomu SwingWorker<T, V> oraz Task<V>/ Service<V> do obsługi postępu, anulowania i błędów.

Po co programom wątki i równoległość: od responsywnego interfejsu po wykorzystanie wszystkich rdzeni procesora. Omawiamy różnicę między procesami a wątkami, rolę głównego wątku main w JVM, praktyczne przypadki użycia (UI, serwery, przetwarzanie plików) oraz ryzyka: race condition, deadlock, a także podstawowe narzędzia synchronizacji, takie jak synchronized. Pokażemy prosty przykład z Thread i uruchomieniem dwóch zadań równolegle.

W wykładzie omawiamy uruchamianie wątków w Javie: poznajemy klasę Thread i interfejs Runnable, uczymy się poprawnie wywoływać start() i nie mylić go z run(), używamy klas anonimowych i wyrażeń lambda, uruchamiamy kilka wątków i przyglądamy się cyklowi życia ( NEW → RUNNABLE → TERMINATED). Porozmawiamy o metodach Thread.currentThread(), getName(), oczekiwaniu przez join() oraz typowych błędach, takich jak IllegalThreadStateException.

Omawiamy cykl życia wątku w Javie: od Thread.State (

NEW

,

RUNNABLE

,

BLOCKED

,

WAITING

,

TIMED_WAITING

,

TERMINATED

) do przejść między nimi. Uczymy się zarządzać wątkami za pomocą Thread.sleep(...), join(), interrupt(), diagnozować stan przez isAlive() i getState(), a także unikać przestarzałych metod typu stop()/ suspend()/ resume(). Na końcu — praktyczne wskazówki i najczęstsze błędy.

Jak bezpiecznie przekazywać parametry do wątków przez konstruktor klasy implementującej Runnable, kiedy sensowne są wyrażenia lambda i dlaczego pola lepiej oznaczać jako final. Omawiamy priorytety wątków: metody setPriority/ getPriority, stałe Thread.MIN_PRIORITY, Thread.NORM_PRIORITY, Thread.MAX_PRIORITY i ich wpływ na planistę (scheduler). Plus – nazywanie wątków przez konstruktor, setName/ getName, praktyczny przykład i typowe błędy (wspólny Runnable, settery, nadzieje pokładane w priorytetach).

W wykładzie wyjaśniamy, czym jest warunek wyścigu: gdy kilka wątków jednocześnie uzyskuje dostęp do wspólnych danych, a wynik zależy od harmonogramu. Na przykładzie inkrementacji counter ++ pokazujemy, dlaczego operacja nie jest atomowa i jak gubią się inkrementy. Omawiamy praktyczny przypadek z rachunkiem bankowym, konsekwencje na produkcji i podejścia do ochrony: synchronized, typy atomowe z java.util.concurrent.atomic (na przykład AtomicInteger), a także niezmienność. Kończymy sekcją „Typowe błędy”, w której wyjaśniamy, dlaczego bugi związane z Thread rzadko są wychwytywane testami i dlaczego „leczenie” ich przez Thread. sleep( 1) jest bez sensu.

Ten wykład dotyczy tego, czym jest zasób współdzielony w aplikacjach wielowątkowych, dlaczego powstają stany wyścigu (race condition) i „utracone aktualizacje”, oraz jak chronić dane za pomocą synchronized. Omówimy podstawowe techniki synchronizacji (metody i bloki), porozmawiamy o nowoczesnych narzędziach z java.util.concurrent ( Lock, ReentrantLock, Semaphore i in.), zobaczymy praktyczne przykłady z inkrementacją licznika oraz typowe błędy (nieatomowość i ++, niewłaściwy obiekt blokady, mity na temat volatile).

Praktyczny wykład o wielowątkowości: omawiamy, jak działa słowo kluczowe synchronized (bloki i metody, monitor obiektu oraz blokada na poziomie klasy ClassName.class), czym różni się widoczność zmian przez volatile od atomowości operacji, dlaczego wygodnie jest używać flag boolean jako volatile, a inkrementacja count ++ wymaga synchronizacji. Porównamy, kiedy wybrać synchronized, a kiedy – volatile, i omówimy typowe błędy.

Praktyczne porównanie klasycznej synchronizacji za pomocą synchronized z bardziej elastycznymi prymitywami z pakietu java.util.concurrent.locks: ReentrantLock i ReadWriteLock. Omówimy, jak jawnie zarządzać blokadami ( lock()/ unlock(), tryLock() z timeoutem), jak skalować odczyt za pomocą ReentrantReadWriteLock, czym jest „sprawiedliwość” ( fair mode), gdzie który mechanizm ma sens i jakie błędy zdarzają się najczęściej.

W tej lekcji omówimy kluczowe prymitywy synchronizacji w Javie: jak chronić sekcje krytyczne za pomocą synchronized i klasy ReentrantLock (metody lock()/ unlock(), konstrukcja try- finally), a także jak ograniczać równoległość przez Semaphore (metody acquire()/ release()). Porównamy muteks i semafor w tabeli, rozważymy praktyczne przypadki (bank, serwer z limitem połączeń) oraz typowe błędy, prowadzące do deadlock i spadków wydajności.

Praktyczne omówienie częstych błędów wielowątkowości w Javie: zapomniane unlock()/ release() przy ReentrantLock i Semaphore (rozwiązuje się przez try- finally), wybór niewłaściwego monitora dla synchronized, wzajemne blokady (deadlock) i kolejność przejmowania blokad, nadmierna synchronizacja, a także granice stosowalności volatile oraz zamiana na AtomicInteger. Przykłady, wskazówki i przystępne analogie — żeby kod nie „stawał dęba”.