Wielowątkowość w Javie
Wielowątkowość w Javie
Kod szkolenia: JAVA-WAT
Szkolenie adresowane jest do programistów Java, aplikacji wielowątkowych.
Celem szkolenia jest dokładne poznanie API Java w zakresie wielowątkowości i nabycie umiejętności posługiwania się nim. Od podstaw współpracy między wątkami, poprzez zaawansowane operacje typu CAS, na dokładnym przećwiczeniu biblioteki java.util.concurent skończywszy. Także z uwzględnieniem wpływu systemów operacyjnych, czy optymalizacji Java, a nawet samych procesorów - związanych z tym problemów programowania wielowątkowego i sposobów ich rozwiązywania.
5 dni, po 8 godzin. Łącznie 40 godzin(y) szkolenia.
Oczekiwane przygotowanie słuchaczy przed szkoleniem
Od uczestników wymaga się umiejętności programowania w języku Java.
Polecane szkolenia uzupełniające
Szkolenie poprzedzające - Programowanie w Java (JAVA-PRO).
Inne szkolenia zaawansowane:
wydajność (JAVA-WAT), projektowanie (JAVA-WZO), architektura (JAVA-ARCH)
- Wprowadzenie do wielowątkowości
- Czym jest wielowątkowość
- Przetwarzanie liniowe
- Przetwarzanie wielowątkowe
- Przetwarzanie równoległe (paraller)
- Przetwarzanie współbieżne (concurrent)
- Wywłaszczanie wątków
- Szeregowanie wątków
- Problemy szeregowania
- Priorytety
- Przykłady priorytetów w systemach operacyjnych
- Priorytety w Java
- Współpraca między wątkami
- Producenci i konsumenci
- looping - złe rozwiązanie
- Powiadamianie między wątkami
- Procesy w Javie
- Procesy a wątki
- Różnice między wątkiem a procesem
- Proces a wątek na poziomie systemu operacyjnego
- Model 1:1
- Model N:1
- Model N:M
- Green Threads - Fibers
- Komunikacja między wątkami
- Komunikacja między procesami
- Niskopoziomowe API procesów w Javie
- Klasa Process
- Startowanie procesu
- Runtime.exec()
- ProcessBuilder
- ProcessHandle
- Przykład komunikacji między procesami
- Ograniczenia
- Przegląd rozwiązań wyższego poziomu w Java (logika zdalna)
- Socket
- RMI
- EJB
- WebServices
- Servlets, JSP, JSF
- Wątki w Javie
- Tworzenie wątków w Javie
- Thread
- Runnable
- Startowanie wątków
- Kończenie wątków
- Parametry wątków
- Nazwa wątku
- Priorytety wątków
- Wątki demoniczne
- Grupy wątków
- Dziedziczenie wartości parametrów
- Grupa domyślna
- ThreadGroup
- Wyjątki w wątkach
- Przypadkowe zakończenie pracy
- Obsługa w run()
- Handlery
- Handler dla wątku (Thread.UncaughtExceptionHandler)
- Handler dla grupy (nadpisanie uncaughtException)
- Handler dla wszystkich (default)
- Wątki wirtualne
- Podstawowa współpraca między wątkami
- Cykl życia wątku
- Thread.State
- Metody przejścia między stanami
- Szansa dla innych (yield)
- Oczekiwanie czasowe (sleep)
- Poczekanie bez wstrzymania (onSpinWait)
- Oczekiwanie na zakończenie (join)
- Współpraca wait-notify
- Sekcja krytyczna (synchronized)
- Monitory
- Blok synchronizowany
- Metoda synchronizowana
- Statyczne metody synchronizowane a monitor
- Komunikacja wait()-notify()/notifyAll()
- Przerwanie oczekiwania
- interrupt()
- Zagrożenia w aplikacjach wielowątkowych
- Ograniczenia cyklu życia wątku
- Metody deprecated klasy Thread
- Livelock
- Brak atomowości wykonania
- Zagrożenia blokowania wątków
- Monitory obiektów Class a własny ClassLoader
- Wyścig (hazard)
- Brak określenia sekcji krytycznej
- Błędne monitory
- Zagłodzenie (starvation)
- Zbyt długie przetrzymywanie blokady
- Problemy priorytetów
- Złe priorytetyzowanie
- Mapowanie priorytetów Java na SO
- Priority Inversion
- Zakleszczenie (deadlock)
- Czym jest deadlock
- Rozwiązanie deadlock dla 2ch wątków
- Ustalenie kolejności zajmowania blokad
- Unikanie blokad - algorytm Dekkera
- Zakleszczenia większej ilości wątków
- Pętla w grafie oczekiwania
- Problem jedzących filozofów
- Algorytm Chandy-Misra
- Narzędzia monitorowania pracy wątków
- JConsole
- Java Visual Virtual Machine
- JMC
- Zadania schedulowane i pule wątków
- Stare API schedulingu
- Timer
- TimerTask
- Różne typy zadań - czyli nie tylko Runnable
- Delayed - czyli zadanie na potem
- Callable - czyli dajcie wynik
- Future - czyli powrót do przyszłości
- RunnableFuture
- FutureTask
- ScheduledFuture
- RunnableScheduledFuture
- Wykonawca zadań
- Executor
- ExecutorService
- AbstractExecutorService
- Pule wątków
- ThreadPoolExecutor
- RejectedExecutionHandler
- ThreadFactory
- Executors
- Kolejki zadań - przegląd kolejek blokujących
- Scheduling w pulach wątków
- ScheduledExecutorService
- ScheduledThreadPoolExecutor
- Pule wątków a konsumpcja wyników
- CompletionService
- ExecutorCompletionService
- Fork-Join API
- Algorytmy dziel i rządź
- ForkJoinPool
- ForkJoinTask
- RecursiveAction
- RecursiveTask
- CountedCompleter
- Flow - programowanie reaktywne
- Flow
- Flow.Publisher
- Flow.Subscriber
- Flow.Subscription
- Flow.Processor
- SubmissionPublisher
- "Promises" w Javie
- CompletableFuture
- CompletionStage
- GUI a wielowątkowość w Javie
- Problemy wielowątkowości w GUI
- Rozwiązania AWT - EventQueue
- Rozwiązania SWING
- SWING rozszerza AWT
- SwingUtilities
- Kontrola postępów
- SwingWorker
- RunnableFuture
- Kończenie pracy
- Operacje atomowe w Javie
- Czym jest atomowość?
- Problemy braku atomowości
- Unikanie problemu
- Stałe (final)
- Dane lokalne wątku
- ThreadLocal
- InheritableThreadLocal
- ThreadLocalRandom
- LongAccumulator
- DoubleAccumulator
- LongAdder
- DoubleAdder
- Gwarantowana atomowość w Javie
- Bariery pamięci - opis i rodzaje
- Wymuszanie barier pamięci
- volatile
- Synchronizacja
- Stałe
- Specyficzne happens-before
- happens-before w java.util.concurrent
- Leniwy zapis (lazySet) i klasy atomowe
- Operacje atomowe typu Compare And Set (CAS)
- CAS w API Javy (java.util.concurrent.atomic i java.lang.invoke)
- Operacje CAS na dynamicznych referencjach - VarHandle
- Operacje CAS na typach prostych
- AtomicBoolean
- AtomicInteger
- AtomicLong
- Operacje CAS na referencjach
- AtomicReference
- AtomicMarkableReference
- AtomicStampedReference
- Operacje CAS na tablicach
- AtomicIntegerArray
- AtomicLongArray
- AtomicReferenceArray
- Operacje CAS na zmiennych volatile
- AtomicIntegerFieldUpdater
- AtomicLongFieldUpdater
- AtomicReferenceFieldUpdater
- Spinlock - pętle CAS jako alternatywa synchronizacji
- Zaawansowana współpraca między wątkami
- Monitor a Lock (java.util.concurrent.locks)
- Lock jako alternatywa synchronized
- Interfejs Lock
- Interfejs ReadWriteLock
- Gotowe realizacje Lock
- ReentrantLock (Lock)
- ReentrantReadWriteLock (ReadWriteLock)
- ReentrantReadWriteLock.ReadLock (Lock)
- ReentrantReadWriteLock.WriteLock (Lock)
- StampedLock
- Współpraca między wątkami na Lock
- Interfejs Condition
- Metody interfejsu Lock
- newCondition()
- lock()
- tryLock, tryLock(time, unit)
- unlock()
- Condition jako alternatywa wait-notify
- Bez synchronizacji
- Z wsparciem oczekiwania czasowego
- Z wsparciem grup oczekiwania (wiele condition)
- Tworzenie własnych klas blokad
- Lock nie zawsze wystarczy
- Gotowe klasy bazowe
- LockSupport
- AbstractOwnableSynchronizer
- AbstractQueuedSynchronizer
- AbstractQueuedLongSynchronizer
- Zaawansowane konstrukcje Spinlock
- Inne implementacje blokad (java.util.concurrent)
- Monitor a semafor (Semaphore)
- Wszyscy na start (CountDownLatch)
- Kamienie milowe zespołu (CyclicBarrier)
- Dajcie kierownika (Phaser)
- Coś za coś (Exchanger)
- Z ręki do ręki (SynchronousQueue)
- Przegląd kolekcji blokujących
- Kolekcje a wielowątkowość w Javie
- "Stare" kolekcje Java a wielowątkowość
- Hashtable
- Vector
- Stack
- Collections API a wielowątkowość
- Podstawy Collections API
- Opakowanie w proxy synchronizujące
- Synchronizacja iteracji
- Kolekcje wielowątkowe java.util.concurrent
- Cechy ogólne
- Najczęściej brak blokowania na monitorach
- CAS
- Często kosztowne size()
- "Happens-before"
- Kolekcje blokujące
- BlockingQueue
- ArrayBlockingQueue
- LinkedBlockingQueue
- PriorityBlockingQueue
- DelayQueue
- SynchronousQueue
- TransferQueue
- LinkedTransferQueue
- BlockingDeque
- LinkedBlockingDeque
- Kolekcje kopiujące przy zapisie
- CopyOnWriteArrayList
- CopyOnWriteArraySet
- Kolekcje współbieżne
- Oparte na wait-free
- Czym jest wait-free
- ConcurrentLinkedQueue
- ConcurrentLinkedDeque
- Oparte na operacjach CAS
- ConcurrentMap
- ConcurrentHashMap
- Oparte na skip list
- Czym jest skip list
- ConcurrentNavigableMap
- ConcurrentSkipListMap
- ConcurrentSkipListSet
- Podsumowanie ze względu na interfejsy kolekcji
- Zbiory wielowątkowe (Set)
- Mapy wielowątkowe (Map)
- Listy wielowątkowe (List)
- Kolejki wielowątkowe (Queue)
- Wielowątkowe kolejki dwukierunkowe (Deque)
- Porównanie wydajności java.util.concurrent z Collecions API
- Grabage Collector a wielowątkowość
- Stop The World
- Model Pamięci
- Słaba teoria generacji
- Minor collections
- Major collections
- Podział pamięci
- Metaspace
- Stara generacja (tenured)
- Nowa generacja (young)
- Eden
- Survivor Spaces
- Parametry wydajnościowe Garbage Collector
- Pauza (pauses/responsiveness)
- Przepustowość (throughput)
- Zużycie pamięci (footprint)
- Różne potrzeby
- Różne rodzaje Garbage Collector a wielowątkowość
- Serial collector
- Paraller collector
- Concurrent collector (CMS)
- G1
- Eksperymentalne: Epsilon, Z, Shenandoah
- Różne rodzaje Garbage Collector a obszary pamięci
- Wybór Garbage Collector
- Better choice
- Jawny wybór
- Podgląd pracy Garbage Collector'a
- Opcje podglądu
- Narzędzia graficzne
- Wskazówki doboru Garbage Collector (GC)
- Asynchroniczne IO
- Asynchroniczna praca na plikach
- AsynchronousChannel
- AsynchronousFileChannel
- CompletionHandler
- Asynchroniczna praca na gniazdkach
- AsynchronousByteChannel
- AsynchronousSocketChannel
- AsynchronousServerSocketChannel
- CompletableFuture w java.net.http (wprowadzenie)
- Wzorce wielowątkowości a rozwiązania w Javie
- Wzorce blokowania
- Scoped locking
- synchronized
- try-finally + Lock
- Lock z AutoCloseable
- Strategized locking
- Proxy synchronizujące (np. z Collections)
- Dziedziczenie z nadpisaniem metod
- Interceptory/Aspekty/Dekoratory
- Thread-safe interface
- Fasada (GOF) + blokowanie
- Spin-lock
- Pętle i operacje CAS klas atomowych
- Test-And-Test-And-Set (TATAS)
- Ticket lock
- Listy uczestników
- Double-checked locking
- Problemy na przykładzie Singletona
- Wzorce współpracy
- Observer
- Observable i Observer
- Flow API
- PropertyChangeSupport
- Multicaster - Observer bezpieczny wielowątkowo
- AWTEventMulticaster
- Blocking Queue
- Interfejs BlockingQueue
- Standardowe implementacje BlockingQueue
- Producer-Consumer
- wait-notify
- Lock+Condition
- Kolejki blokujące
- ExecutorCompletionService
- Czasem Flow API
- Wzorce zarządzania wątkami
- Thread per request
- Thread.start()
- Własna implementacja Executor
- Thread per session
- Timer
- Executors.newSingleThreadExecutor()
- Executors.newSingleThreadScheduledExecutor()
- Rozwiązania SWING i AWT
- EventQueue
- SwingUtilities
- Thread pool
- SwingWorker
- ForkJoinPool
- (Sheduled)ThreadPoolExecutor
- Executors.newFixedThreadPool()
- Executors.newScheduledThreadPool()
- Thread pool - leaky bucket (cieknące wiadro)
- Executors.newCachedThreadPool()
- Executors.newWorkStealingPool()
- Konstruktor ThreadPoolExecutor czy ForkJoinPool
- Wzorce obsługi zdarzeń
- Executor (Command-Invoker)
- EventQueue
- SwingUtilities
- SwingWorker
- ThreadPoolExecutor
- ForkJoinPool
- ExecutorCompletionService
- CompletableFuture
- Scheduler
- Timer
- ScheduledThreadPoolExecutor
- Wzorce wywołań asynchronicznych
- Future
- Future i podinterfejsy
- Implementacje Future
- Active Object
- Dla metod bez wyników: Proxy + ThreadPoolExecutor
- Dla metod z wynikami: Facade + Future + ThreadPoolExecutor
- Half-Sync/Half-Async
- W GUI: Facade +
- EventQueue.invokeAndWait()
- SwingUtilities.invokeAndWait()
- Nasza logika: Facade + ThreadPoolExecutor + Future.get()
- Wzorce inicjalizacji
- Activator
- Active Object za dynamicznym proxy
- Ograniczenia opakowywanego API
- Acceptor-Connector
- ServerSocket i Socket
- Reactor
- Obsługa Socket w wątku pobrania
- + Strategy dla różnych rodzajów żądań
- Proactor
- Reactor z obsługą Socket w osobnym wątku
- + Dobór strategii w dedykowanym wątku
- Asynchroniczne IO
- Leader-Followers
- Proactor z redukcją przełączania między wątkami
- + Dobór strategii i obsługa w tym samym wątku
- Asynchroniczne IO
- Wydajność aplikacji wielowątkowych w Javie
- Współpraca zamiast odpytywania
- Ograniczanie blokowania
- Dane lokalne wątków
- Dane na stosie
- Parametry funkcji
- Zmienne lokalne
- Minimalizacja sekcji krytycznych
- Busy-waiting (spinlock)
- Thread.onSpinWait()
- Blokowanie optymistyczne
- Pamiętaj o kolekcjach współbieżnych
- Fork-Join granica opłacalności
- Prawo Amdahla - czyli ograniczenia zrównoleglenia
- Kontrola ilości wątków - pule wątków
- Tuning Javy dla wątków
- ThreadStackSize
- UseTLAB
- EliminateLocks
- UseBiasedLocking