Simple Steps: szkolenia Java, UML i BPMN
"przypomina nieco Sapkowskiego‚ nieco Tolkiena‚ a najbardziej chyba Grę o tron" - szczere-recenzje.pl, "Lektura tej książki wciągnęła mnie bez reszty. Z niecierpliwością czekam na więcej" - Maria Górska, "jeżeli macie ochotę na dobre‚ mocne high fantasy - nie macie wyboru‚ musicie sięgnąć po Wojny Żywiołów" - biblioteczka..., "genialna‚ wciągająca i intrygująca" - Ewelina Kiełbasińska, "Gorąco polecam!" - Addicted to books, "fabuła brzmi po prostu świetnie!" - kasiek-mysli.blogspot.com, "Jest to pozycja obowiązkowa dla każdego fana fantastyki" - moje-ukochane-czytadelka.blogspot.com, "Miałam wrażenie‚ że z każdą kolejną stroną roztacza się przede mną zupełnie inny świat" - biblioteczkaciekawychksiazek, "Zdecydowanie polecam‚ bo jest to kawał dobrze napisanego polskiego high fantasy!" - biblioteczkaciekawychksiazek, "mogę polecić wszystkim fanom tego gatunku" - zapiski-okularnicy.pl, "wciągnie nie tylko fanów fantastyki‚ ale i każdego czytelnika" - subiektywinie.blogspot.com, "Nie spodziewałam się‚ że aż tak mnie wciągnie." - zapiski-okularnicy.pl, "Jest to powieść zdecydowanie warta uwagi." - in-corner-with-book.blogspot.com, "nie mogę się już doczekać‚ kiedy dorwę tom drugi" - biblioteczkaciekawychksiazek.blogspot.com, "Poleciłabym zdecydowanie osobom gustującym w fantastyce" - marzenieliterackie.blogspot.com, "zachwyca także złożoność i różnorodność wątków" - szczere-recenzje.pl, "Nie mogę się doczekać kiedy znów przeniosę się do tego świata" - moje-ukochane-czytadelka.blogspot.com, "Najchętniej od razu sięgnęłabym po kolejną część." - zapiski-okularnicy.pl, "nie spodziewałam się tego po fantasy" - Ewelina Kiełbasińska, "książkę gorąco wam polecam!" - kasiek-mysli.blogspot.com, "autor cały czas utrzymywał mnie w napięciu i ciekawości" - moje-ukochane-czytadelka.blogspot.com, "książkę mogę z czystym sumieniem polecić wszystkim fanom gatunku" - Globster na lubimyczytac.pl, "to książka‚ która pobudziła moją wyobraźnię i ciekawość." - zapiski-okularnicy.pl, "Nie ma tu miejsca na nudę" - in-corner-with-book.blogspot.com

Szkolenia Java, UML i BPMN: Wielowątkowość w Javie


Wielowątkowość w Javie

Wielowątkowość w Javie

Kod szkolenia: JAVA-WAT

Adresaci szkolenia

Szkolenie adresowane jest do programistów Java, aplikacji wielowątkowych.

Cele szkolenia

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.

Czas trwania szkolenia

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)

Program szkolenia

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

simple-steps.pl, simplesteps.pl są własnością SIMPLE Podbielski Michał