Java Wielowątkowość Asynchroniczność Równoległość

Java Wielowątkowość Asynchroniczność Równoległość

Poznaj wielowątkowość, asynchroniczność i programowanie równoległe w języku Java!

• Naucz się, jak w Java działają mechanizmy wielowątkowości, asynchroniczności i programowania równoległego.
• Przygotuj się do rozmów kwalifikacyjnych – to jedne z najczęściej poruszanych zagadnień.
• W kursie obejrzysz 16h nagrań.

Chcesz pójść o krok dalej? Skorzystaj z indywidualnego mentoringu!

• Nauka krok po kroku od podstaw po rozbudowane projekty w Twoim portfolio.
• Plan nauki dostosowany do Twoich celów zawodowych.
• Nieograniczony kontakt w dni robocze, spotkania 1 na 1 na żywo.
• Pełne wsparcie na każdym etapie nauki.
• Nauka we własnym tempie.
• Zadania teoretyczne i praktyczne – każde zadanie zawiera moje rozwiązanie.
• Wspólne tworzenie praktycznych projektów, które wzbogacą Twoje portfolio.
• Wiedza i doświadczenie, które przybliżą Cię do pracy w IT.
• Poznaj wszystkie moje kursy: link
• Napisz do mnie: kontakt@km-programs.pl

Zobacz, jak łatwo możesz uczyć się z platformą!

Plan kursu

Wprowadzenie

• Lekcja 1: Wprowadzenie
• Lekcja 2: Wprowadzenie teoretyczne – Porównanie Współbieżności, Wielowątkowości, Równoległości oraz Asynchroniczności
• Lekcja 3: Wprowadzenie teoretyczne – Proces i wątek

Wielowątkowość

• Lekcja 4: Tworzenie wątków – Klasa Thread
• Lekcja 5: Tworzenie wątków – Interfejs Runnable
• Lekcja 6: Cykle życia wątku
• Lekcja 7: Odpowiadamy na pytania teoretyczne do interview z poprzednich lekcji – część 1
• Lekcja 7: Odpowiadamy na pytania teoretyczne do interview z poprzednich lekcji – część 2
• Lekcja 8: Problemy wielowątkowości – wyścigi
• Lekcja 9: Synchronizacja wątków
• Lekcja 10: Problem widoczności zmiennych – słowo kluczowe volatile
• Lekcja 11: Problem producenta i konsumenta – metody wait, notify, notifyAll
• Lekcja 12: Inne problemy wielowątkowości – starvation, deadlock, livelock
• Lekcja 13: Rozbudowana implementacja problemu producent-konsument
• Lekcja 14: Odpowiadamy na pytania teoretyczne do interview
• Lekcja 15: Synchronizacja z wykorzystaniem Lock
• Lekcja 16: Ciekawe właściwości implementacji interfejsu Lock
• Lekcja 17: Implementacja problemu producent-konsument z wykorzystaniem Lock oraz Condition
• Lekcja 18: Poznajemy właściwości instancji typu ExecutorService
• Lekcja 19: Poznajemy różne rodzaje instancji typu ExecutorService – część 1
• Lekcja 20: Poznajemy różne rodzaje instancji typu ExecutorService – część 2
• Lekcja 21: Poznajemy różne rodzaje instancji typu ExecutorService – część 3 + wprowadzenie Do ForkJoinPool
• Lekcja 22: Praktyczny przykład wykorzystania ForkJoinPool z instancjami typu RecursiveTask
• Lekcja 23: Wprowadzenie typów Callable oraz Future
• Lekcja 24: Porównanie metod ExecutorService
• Lekcja 25: ThreadFactory
• Lekcja 26: Semaphore
• Lekcja 27: Synchronizacja pracy wątków z wykorzystaniem CountDownLatch
• Lekcja 28: Synchronizacja pracy wątków z wykorzystaniem CyclicBarrier
• Lekcja 29: Synchronizacja pracy wątków z wykorzystaniem Phaser
• Lekcja 30: Kontenery synchroniczne – ArrayBlockingQueue
• Lekcja 31: Kontenery synchroniczne – wprowadzenie do PriorityBlockingQueue
• Lekcja 32: Kontenery synchroniczne – sposoby ustalania priorytetu dla elementów PriorityBlockingQueue
• Lekcja 33: Kontenery synchroniczne – kolejka LinkedBlockingQueue
• Lekcja 34: Kontenery synchroniczne – kolejka ConcurrentLinkedQueue
• Lekcja 35: Kontenery synchroniczne – kolejka LinkedTransferQueue oraz AtomicInteger – część 1
• Lekcja 36: Kontenery synchroniczne – kolejka LinkedTransferQueue oraz AtomicInteger – część 2
• Lekcja 37: Kontenery synchroniczne – implementacja problemu producent – konsument za pomocą kolejki LinkedTransferQueue
• Lekcja 38: Kontenery synchroniczne – SynchronousQueue – część 1
• Lekcja 39: Kontenery synchroniczne – SynchronousQueue – część 2
• Lekcja 40: Kontenery synchroniczne – LinkedBlockingDeque
• Lekcja 41: Kontenery synchroniczne – DelayQueue
• Lekcja 42: Kontenery synchroniczne – podsumowanie + kolejka ConcurrentLinkedDeque
• Lekcja 43: Kontenery synchroniczne – ConcurrentMap, ConsurrentHashMap, ConcurrentSkipListMap, ConcurrentSkipListSet
• Lekcja 44: Kontenery synchroniczne – Przegląd metod klasy Collections do tworzenia kontenerów synchronicznych
• Lekcja 45: Kontenery synchroniczne – CopyOnWriteArrayList

Asynchroniczność

• Lekcja 46: Wprowadzenie do typu CompletableFuture
• Lekcja 47: Podstawowe metody klasy CompletableFuture
• Lekcja 48: Zarządzanie poziomami asynchroniczności w instancjach CompletableFuture
• Lekcja 49: Obsługa błędów w zadaniach asynchronicznych przetwarzanych w CompletableFuture
• Lekcja 50: Przegląd kolejnych metod klasy CompletableFuture
• Lekcja 51: Przegląd kolejnych metod klasy CompletableFuture
• Lekcja 52: Przegląd kolejnych metod ( runAfterEither, runAfterEitherAsync, resultNow )
• Lekcja 53: Przegląd kolejnych metod ( thenAcceptBoth, thenAcceptBothAsync, thenCombine, thenCombineAsync, thenCompose, thenComposeAsync )
• Lekcja 54: Przegląd kolejnych metod ( minimalCompletionStage, newIncompleteFuture, obtrudeException, whenComplete )

Równoległość

• Lekcja 63: Programowanie równoległe, wprowadzenie do strumieni równoległych
• Lekcja 64: Sposoby implementowania strumienia równoległego
• Lekcja 65: Analizujemy średni czas wykonania operacji przez strumień równoległy
• Lekcja 66: Analizujemy wydajność pracy strumieni równoległych
• Lekcja 67: Porównanie działania metod parallel oraz parallelStream
• Lekcja 68: Biblioteka Parallel Collectors

Virtual threads, structured concurrency

• Lekcja 69: Wprowadzenie do virtual threads
• Lekcja 70: Sposoby tworzenia virtual threads
• Lekcja 71: Zasada działania virtual threads (carrier threads, pinned virtual threads)
• Lekcja 72: Zarządzanie pamięcią w procesie życia virtual thread
• Lekcja 73: Wprowadzenie mechanizmu structured concurrency
• Lekcja 74: Implementacja mechanizmu structured concurrency w oparciu o typ StructuredTaskScope
• Lekcja 75: Implementacja mechanizmu structured concurrency w oparciu o typ StructuredTaskScope.ShutdownOnFailure
• Lekcja 76: Implementacja mechanizmu structured concurrency w oparciu o typ StructuredTaskScope.ShutdownOnSuccess
• Lekcja 77: Implementacja własnej implementacji mechanizmu structured concurrency, rozszerzającego klasę StructuredTaskScope.
• Lekcja 78: Implementacja mechanizmu structured concurrency do obsługi dużej ilości zadań
• Lekcja 79: Wprowadzenie do scoped value
• Lekcja 80: Wykorzystanie scoped value w przykładowym serwisie
• Lekcja 81: Implementacja logiki wykorzystującej scoped value
• Lekcja 82: Omówienie metod do pracy z instancją scoped value
• Lekcja 83: Porównanie scoped value do thread local variable