Многопоточность в Java

Изучи потоки от основ до готового production-кода. Научишься легко писать многопоточные приложения, проходить собеседования на уровень middle+ уверенно и претендовать на вакансии с зарплатой в два раза выше.

Для кого этот курс:

Новичок, знающий только основы Java и Spring

• Сейчас самое подходящее время для освоения многопоточности. Гораздо легче изучить её в начале карьеры, чем догонять под давлением сложных задач.
• Junior/Middle разработчик на Java
• Можешь создавать REST API и работать с базами данных, но многопоточность остаётся непонятной, что мешает доступу к более интересным проектам.
• Хочешь улучшить свои навыки
• Тебе важно расти как программист и повышать заработок за счёт квалификации, а не за счёт самопрезентаций и вымышленной биографии.

Программа:

Модуль 1. Под капотом: потоки, процессы, Threads API, JVM, Daemon, Synchronized, Volatile

• Почему многопоточность необходима: где однопоточность «тормозит» систему; влияние очередей и блокирующих операций
• Поток как единица выполнения в общей памяти процесса: общий heap, stack у каждого потока
• Program → Process → Thread: от запуска программы до выполнения кода в потоке
• Планировщик ОС: очереди Ready/Waiting/Blocked; RUNNABLE ≠ RUNNING; стоимость переключений контекста; недетерминированность порядка
• Основной Thread API: Thread/Runnable; start vs run; join; sleep (TIMED_WAITING); interrupt и восстановление флага; отслеживание состояний (getState)
• Daemon vs User: определение, назначение, условия завершения JVM, риски использования демонов для бизнес-логики
• Введение в синхронизацию: race condition; mutex/критическая секция; synchronized; volatile;

Результат:

• Поймёшь, как устроены процессы и потоки в JVM и ОС, где у них общая и изолированная память
• Сможешь уверенно создавать и управлять потоками: запуск, ожидание, усыпление, корректная остановка.
• Научишься объяснять работу планировщика, очереди Ready/Waiting/Blocked и почему порядок выполнения непредсказуем
• Будешь различать user- и daemon-потоки и поймёшь, когда и почему JVM завершает работу.
• Освоишь базу синхронизации: зачем нужен mutex, когда использовать synchronized, а когда volatile (видимость)

Модуль 2. Управление хаосом: JMM, Reordering, ReentrantLock, Semaphore, Deadlock, Livelock

• Java Memory Model (JMM): program order, happens-before, основные HB-рёбра (unlock→lock, volatile write→read, start/join).
• Reordering: где возможен (компилятор/JIT/CPU) и почему без HB порядок не гарантирован; volatile — видимость/порядок, но не атомарность
• Межпоточная сигнализация: монитор, очереди EntryList/WaitList, wait/notify/notifyAll, spurious wakeups и правило while; тайм-ауты ожидания.
• ReentrantLock и Condition: re-entry, lockInterruptibly (), tryLock (timeout), await/signal, несколько условий ожидания.
• Semaphore: permits, ограничение параллелизма, fair/non-fair режимы.
• ReadWriteLock: совместимость читателей, эксклюзивный писатель, отсутствие безопасного апгрейда read→write, starvation и fair-режим.
• CountDownLatch: одноразовый барьер N→0, await (timeout), сценарии start-gate/completion-gate.
• Атомики и CAS: Atomic*, CAS-цикл, конфликты и спины, ABA и AtomicStampedReference.
• Deadlock: как обнаружить, условия Коффмана, «обедающие философы», порядок локов, tryLock (timeout) + откат.
• Livelock: «уступчивые» симметричные протоколы, разрыв симметрии (backoff/приоритет).
• ThreadLocal: внутренняя модель (ThreadLocalMap), кейсы применения, утечки в пулах и best-practices
• Практика: собственная ArrayBlockingQueue на synchronized + wait/notify, продюсеры/консюмеры, проверка корректности.

Результат:

• Узнаешь, как Java гарантирует видимость и порядок между потоками (Java Memory Model, happens-before, reordering).
• Получишь набор практических приёмов межпоточной сигнализации (wait/notify/notifyAll) и научишься избегать типовых багов (потерянные сигналы, ложные пробуждения).
• Сможешь осознанно выбирать примитив синхронизации (ReentrantLock/Condition, Semaphore, ReadWriteLock, CountDownLatch) под задачу и использовать тайм-ауты/прерывание для выхода из вечного ожидания.
• Научишься применять атомики и CAS, объяснять ABA-проблему и её решения.
• Сможешь воспроизводить и устранять deadlock и livelock (включая «уступчивый» сценарий), работать с ThreadLocal без утечек и реализовать безопасную блокирующую очередь

Модуль 3. Продвинутые инструменты: ExecutorService, CompletableFuture, Concurrent Collections, Virtual Threads

• I/O-bound vs CPU-bound: задачи, ограниченные скоростью операций ввода-вывода, и задачи, ограниченные вычислительными ресурсами; определения, метрики и стратегия выбора пула потоков.
• ExecutorService и виды ThreadPoolExecutor: FixedThreadPool, CachedThreadPool, ScheduledThreadPool и SingleThreadExecutor; работа очереди задач, рабочих потоков и механизмы завершения пула.
• ForkJoinPool: модель work-stealing (распределения задач с кражей работы), использование классов RecursiveTask и RecursiveAction; общий ForkJoinPool для параллельных потоков (parallel streams) и пул по умолчанию для CompletableFuture.
• Parallel Streams: когда применение оправдано, влияние числа доступных ядер процессора (Runtime.getRuntime().availableProcessors()), и почему такие потоки не годятся для сценариев с интенсивным вводом-выводом.
• Асинхронная модель: интерфейсы Runnable, Callable и Future; жизненный цикл Future; использование CompletableFuture, основные операторы, обработка ошибок и таймауты.
• Потокобезопасные коллекции: ConcurrentHashMap, CopyOnWriteArrayList, ArrayBlockingQueue и LinkedBlockingQueue (массив против связного списка, примеры проблем при использовании обычных HashMap и ArrayList в многопоточности.
• Virtual Threads: создание через Thread.ofVirtual().start() и Executors.newVirtualThreadPerTaskExecutor(); как JVM сопоставляет виртуальных и системных потоков (N к M), механизмы монтирования и размонтирования, сравнение с потоками операционной системы и ограничения в java-21

Результат:

• Поймёшь разницу между IO-bound и CPU-bound задачами и научишься выбирать модель выполнения под профиль нагрузки (ThreadPoolExecutor vs ForkJoinPool vs Virtual Threads)
• Сможешь безопасно работать с пулами потоков: конфигурация, отправка задач, корректное завершение (shutdown/awaitTermination), анти-паттерны ожидания на get/join без нужды
• Освоишь Runnable/Callable/Future и построение неблокирующих цепочек на CompletableFuture (thenApply/thenCompose/thenCombine/allOf/anyOf, обработка ошибок exceptionally/handle)
• Изучишь устройство и гарантии популярных конкурентных коллекций (ConcurrentHashMap, CopyOnWriteArrayList, ArrayBlockingQueue, LinkedBlockingQueue) и применишь их вместо небезопасных аналогов под конкуренцией.
• Поймешь, как работают Virtual Threads (Loom): сопоставление с carrier-потоками, монтирование/размонтирование стека, где они выигрывают, а где нет; увидишь практические ограничения (thread pinning, тяжёлые ThreadLocal).
• Сможешь сравнить выполнение на обычных пулах и на VT на типичных I/O-сценариях (десятки тысяч задач) и сделать обоснованный выбор

Модуль 4. Боевое крещение: реальный production-case проект

• Thread-per-Request в Tomcat — классическая модель, где каждому запросу выделяется поток. Покажем, где её ограничения и как это влияет на масштабирование
• Event-loop и WebFlux / Netty — неблокирующая архитектура, где один поток обслуживает тысячи соединений.
• Virtual Threads (Java 21+) — новая эпоха Java-параллелизма. Подключим виртуальные потоки в Spring Boot и покажем, как убрать боль реактивщины без потери производительности
• I/O-bound и CPU-bound, закон Амдала — объясняем, почему многопоточность не всегда ускоряет, и как найти оптимальный баланс
• Rate-limiters и HikariCP — где возникают «узкие места» в реальных production-сервисах и как их диагностировать и предотвратить
• План деградации и изоляция ресурсов — как защитить систему, если одно из API начинает тормозить
• Финальный прод-кейс — очередь задач, асинхронный раннер, три внешних API (Stock, Pricing, Shipping), статусы NEW → IN PROGRESS → DONE/FAILED. Реальный сценарий с архитектурой, близкой к продакшену.

Результат:

• Поймёшь, как Spring Boot и Tomcat обрабатывают параллельные запросы (модель thread-per-request)
• Увидишь воочию контраст с event-loop/WebFlux
• Разберёшься в типовых узких местах (очереди, пулы, лимиты) и применишь эти знания на практике
• Реализуешь production-like асинхронный обработчик заказов с ретраями и агрегацией результатов
• На выходе будешь уметь диагностировать bottleneck, проектировать очередь задач и использовать виртуальные потоки там, где они дают преимущество

Бонусы курса:

Чек-лист «20 ошибок в многопоточности»

• PDF с разбором типичных ошибок, которые встречаются даже у опытных разработчиков.
  • Ошибка: использование HashMap в многопоточности
  • Решение: ConcurrentHashMap
  • Ошибка: блокировка под synchronized на длинные операции
  • Решение: выносить блокировку на минимум
  • Ошибка: забыли про volatile при доступе из разных потоков
  • Решение: понимание visibility
• И ещё 17 реальных примеров с объяснением, как исправлять
• Используй как шпаргалку для код-ревью. Особенно полезно перед собеседованиями — многие задачи как раз про это.

Видео — топ-10 вопросов на собеседовании

• Формат: «Как отвечать на вопросы про потоки, чтобы звучать как уверенный middle+».
  • Реальные вопросы с собеседований
  • Как объяснять сложные темы простым языком
  • Какие примеры приводить, чтобы быть убедительным
  • Как вести себя, если не знаешь ответа (подсказка: это нормально)
  • Разбор типичных «ловушек» в вопросах интервьюеров
• Это как репетиция интервью — после просмотра ты будешь звучать уверенно.