Lekcje

Wyjaśniamy, dlaczego klasyczny ThreadLocal traci aktualność w świecie wątków wirtualnych i jak zastępuje go ScopedValue: kontekst powiązany z zakresem wykonania, a nie z wątkiem. Krok po kroku pokazujemy przekazywanie kontekstu (użytkownik, REQUEST_ID), zagnieżdżone zakresy i ich przesłanianie, integrację z wątkami wirtualnymi ( Executors. newVirtualThreadPerTaskExecutor()). Omawiamy porównanie ThreadLocal vs ScopedValue, praktyczne porady, ograniczenia oraz spojrzenie na Structured Concurrency (preview).

Structured Concurrency przekształca chaotyczny zbiór wątków w zarządzaną hierarchię zadań: uruchamiasz podzadania w wirtualnych wątkach wewnątrz StructuredTaskScope, czekasz na nie przez join(), centralnie obsługujesz błędy throwIfFailed() i pobierasz wyniki resultNow()/ result(). Omówimy polityki zakończenia ShutdownOnFailure i ShutdownOnSuccess, porównamy z CompletableFuture, zobaczymy przykłady agregatora HTTP oraz typowe błędy podczas używania konkurencyjności strukturalnej.

Jak poprawnie anulować długie i blokujące operacje w Javie: kooperatywne przerywanie przez Thread.interrupt(), anulowanie zadań przez Future.cancel() i zachowanie CancellationException, timeouty i anulowanie w CompletableFuture ( orTimeout, completeOnTimeout), structured concurrency z StructuredTaskScope, wspólny deadline (time‑budget) i propagacja timeoutów w dół stosu (w tym Instant/ Duration oraz Scoped Values). Omawiamy praktykę pracy z blokującym IO i typowe błędy.

W tej lekcji omawiamy synchronizatory wysokiego poziomu z java.util.concurrent: CountDownLatch, CyclicBarrier, Phaser i Exchanger. Uczymy się koordynować uruchomienie i zakończenie zadań poprzez await()/ countDown(), budować wielorazowe fazy i działania barierowe z await(), zarządzać dynamicznymi uczestnikami „orkiestry” za pomocą register()/ arriveAndAwaitAdvance()/ arriveAndDeregister() oraz wymieniać dane parami przez exchange(). W praktyce zrealizujemy masowy start workerów i „tik gry”, a także omówimy typowe błędy: jednorazowość CountDownLatch, obsługę BrokenBarrierException i poprawne deregister(). Wszędzie obędziemy się bez bólu z wait()/ notify().

Gdy ReentrantReadWriteLock i klasyczny ReadWriteLock zaczynają się dławić pod wysokim obciążeniem, z pomocą przychodzi StampedLock z optymistycznym odczytem: tandem tryOptimisticRead + validate daje niemal „darmowe” odczyty przy rzadkich zapisach. Omówimy tryby blokad, pracę ze znacznikami, ograniczenia związane z reentrantnością, porównamy z ReentrantReadWriteLock, a także przyjrzymy się licznikom o niskiej konkurencji – LongAdder i LongAccumulator – oraz temu, dlaczego wyprzedzają AtomicLong przy konkurencji. Zakończymy praktyką: cache z przewagą odczytów i mini-benchmarkiem.

Omówimy zasady widoczności i porządkowania operacji w Java Memory Model: co oznacza relacja happens-before, jak i kiedy pomagają volatile, synchronized, pola final ( final) oraz dlaczego bez nich pojawiają się „nieświeże” dane. Pokażemy bezpieczną publikację obiektów, poprawny double-checked locking, niskopoziomowy dostęp przez VarHandle, wpływ false sharing i adnotację @Contended, a także praktyczne uwagi dotyczące Thread.start()/ Thread.join(), Future.get() oraz mikrobenchmarków JMH.

Praktyczny przewodnik po równoległej pracy z plikami w Javie: kiedy wielowątkowość rzeczywiście przyspiesza IO, a kiedy nie; wybór narzędzi — Thread, pula wątków przez ExecutorService, asynchroniczność z CompletableFuture i strumienie równoległe — a także odczyt dużych plików fragmentami przez FileChannel, bezpieczny zapis do wspólnego logu oraz ograniczenia OS/FS. Omawiamy wzorce uruchamiania zadań, konfigurację pul, metody shutdown()/ awaitTermination() i typowe błędy.

Praktyczny przewodnik po równolegleniu zadań plikowych w Javie: jak włączyć równoległość w Stream API metodą parallel()/ parallelStream(), jak działa i jak konfigurować ForkJoinPool oraz kiedy lepiej użyć RecursiveTask. Omówimy, gdzie równoległość realnie przyspiesza I/O, jak zarządzać wspólną pulą wątków i jak bezpiecznie zamykać zasoby ( try-with-resources). Na koniec – szybki rzut oka na dostęp pozycyjny przez FileChannel do odczytu/zapisu fragmentów dużych plików.

Jak przyspieszyć przejście dużych katalogów i przetwarzanie tysięcy plików: używamy Files.walk() i strumieni równoległych przez parallel(), rozumiemy rolę ForkJoinPool.commonPool() i konfigurujemy stopień równoległości. Omawiamy, kiedy lepiej przejść na ExecutorService, czym różnią się zadania CPU-bound i IO-bound, piszemy przykład zliczania linii we wszystkich ".java"-plikach i utrwalamy best practices.

Jak przyspieszyć przetwarzanie plików gigabajtowych: dzielimy je na chunki (chunking), używamy dostępu pozycyjnego przez FileChannel i memory-mapped bufory MappedByteBuffer, równoleglimy obliczenia z ExecutorService. Omówimy kluczowe metody wejścia/wyjścia z pozycjonowaniem: position(...), read(...), write(...), kryteria doboru rozmiaru chunku, przykład równoległego zliczania słów i typowe błędy (granice chunków, zasoby, liczba wątków).

Omawiamy, jak zorganizować potok przetwarzania plików zgodnie ze wzorcem Producer–Consumer z bezpieczną wymianą przez BlockingQueue (na przykład ArrayBlockingQueue), jak działają operacje blokujące put() i take(), po co jest mechanizm backpressure i jak poprawnie kończyć wątki za pomocą „poison pill” (na przykład "__END__", a nie null). Uruchamiamy konsumentów przez ExecutorService, dodajemy wizualizację potoku i omawiamy typowe błędy.

Wyjaśniamy, po co Java 9 wprowadziła modułowy system JPMS: dlaczego „ classpath-party” jest zła, jak moduły wprowadzają granice widoczności na poziomie kontenera, czym jest module-info.java i jak pracować z dyrektywami module, exports, requires, opens, uses/ provides. Omówimy zalety (enkapsulacja, jawne zależności, bezpieczeństwo, jlink), obszary zastosowania (w tym java.base, java.sql), przydatne niuanse i typowe błędy podczas migracji (zapomniany exports, pominięty requires, duplikaty nazw modułów).