- Зачем нужна многопоточность: где однопоточность «держит» систему; эффект очередей и блокирующих операций
- Поток как единица исполнения в общей памяти процесса: общий 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 (видимость)
Домашнее задание
Interrupt Me If You Can
Вы — агент, охотящийся за потоками, которые разбегаются по ядрам операционной системы, как хитрые беглецы. Планировщик — хаотичный дирижёр, меняющий порядок исполнения каждую миллисекунду. Иногда вам удаётся поймать задачу и кинуть ей interrupt (), но чаще она ускользает в бесконечный контекст-свитч. В этой лаборатории вы сами проживёте жизнь потока — создадите, запустите, приостановите и остановите его. Познаете разницу между run () и start (), поймёте, зачем нужны daemon-потоки и как volatile и synchronized удерживают порядок в хаосе. В итоге вы обуздаете хаос исполнения — потоки слушаются interrupt (), volatile и synchronized.
- 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 без утечек и реализовать безопасную блокирующую очередь
Домашнее задание
The Lord of the Locks
Вы несёте Единый Lock через земли гонок данных и ловушек дедлоков, чтобы уравновесить хаос в старом легаси-сервисе. На пути вам пригодятся артефакты силы: synchronized, ReentrantLock, AtomicLong, LongAdder — каждый со своими чертами и ценой. Вы соберёте потокобезопасные счётчики, измерите их скорость и устойчивость под нагрузкой, а затем встретитесь с главным врагом — дедлоком — и сломаете его двумя проверенными заклинаниями: тотальным порядком захвата и tryLock (timeout) с откатом. Это путешествие закалит вас: вы выйдете уже как мастер синхронизации, понимающий, где потоки должны ждать, а где им нужно идти.
- 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 (массив против связного ccc, примеры проблем при использовании обычных 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): mapping на carrier‑потоки, mount/unmount стека, где они выигрывают, а где нет; увидит практические ограничения (thread pinning, тяжёлые ThreadLocal).
- Сможешь сравнить выполнение на обычных пулах и на VT на типичных I/O‑сценариях (десятки тысяч задач) и сделать обоснованный выбор
Домашнее задание
Parallel Fiction
Город погряз в хаосе параллельных историй: одни потоки пишут черновики, другие правят текст, третьи ждут ответа от внешних API. Вы — редактор-оркестратор, которому нужно соединить все сюжеты в единую линию. Вы запускаете «фабрику историй», где задачи проходят этапы I/O, CPU и финализации, запустите обработку на ExecutorService + CompletableFuture, соединяя цепочки thenApply и thenCombine, храните результаты в ConcurrentHashMap. А после переведете обработку на Virtual Threads. В итоге — чистая, параллельная обработка, в которой хаос становится системой, а вы понимаете, как управлять асинхронным миром.
- Thread-per-Request в Tomcat — классическая модель, где каждому запросу выделяется поток. Покажем, где у неё пределы и как это влияет на масштабирование
- Event-loop и WebFlux / Netty — неблокирующая архитектура, где один поток обслуживает тысячи соединений.
- Virtual Threads (Java 21+) — новая эпоха Java-параллелизма. Подключим виртуальные потоки в Spring Boot и покажем, как убрать боль реактивщины без потери производительности
- I/O-bound и CPU-bound, закон Амдала — объясняем, почему многопоточность не всегда ускоряет, и как найти оптимальный баланс
- Rate-limiters и HikariCP — где рождаются «бутылочные горлышки» в реальных прод-сервисах и как их диагностировать и предотвратить
- План деградации и изоляция ресурсов — как защитить систему, если одно из API начинает тормозить
- Финальный прод-кейс — очередь задач, асинхронный раннер, три внешних API (Stock, Pricing, Shipping), статусы NEW → IN PROGRESS → DONE/FAILED. Реальный сценарий с архитектурой, близкой к продакшену.
Результат
- Поймёшь, как Spring Boot и Tomcat обрабатывают параллельные запросы (модель thread-per-request)
- Увидишь воочию контраст с event-loop/WebFlux
- Разберёшься в типовых узких местах (очереди, пулы, лимиты) и применишь эти знания в практике
- Реализуешь production-like асинхронный обработчик заказов с ретраями и агрегацией результатов
- На выходе будешь уметь диагностировать bottleneck, проектировать очередь задач и использовать виртуальные потоки там, где они дают выигрыш
Домашнее задание
Async Runner 2049
Мир будущего погрузился в тотальную асинхронность. Запросы рождаются и умирают в очередях, сервисы общаются через HTTP, а потоки — виртуальны. Вы — инженер-бегущий по очереди в неоне мегаполиса, где каждый заказ — цепочка событий: заказ сохраняется в БД, а далее система асинхронно вызывает внешние API — резервирует склад, считает цену, оформляет доставку. Вам предстоит построить реальный production-сервис для асинхронной обработки заказов, с ретраями и нагрузочным тестом в k6. Здесь важно всё — очереди, таймауты, порядок событий. Добейтесь, чтобы ваш Async Runner жил в мире, где всё происходит асинхронно — и ничего не зависает.
REST-эндпойнты POST /orders, GET /orders/{id}. Вставка в orders/tasks в одной транзакции; возвращает идентификатор, не блокируя клиента ожиданием внешних вызовов.
Фан-аут/фан-ин: Pricing, Stock, Delivery. Время ожидания на каждый вызов, маппинг ошибок: 5xx/timeout → retryable, 4xx → non-retryable.
Таблицы orders и tasks (поля status, attempts, next_attempt_at). Реляционная целостность, фиксируем итоговые статусы DONE/FAILED/ERROR.
Эмулирует I/O-задержки и ошибки, чтобы показать поведение пула и ретраев.
Возвращает успех/отказ резервирования; при отказе — завершаем заказ и задачу как ERROR (non-retryable).
Стаб-сервис со случайными задержками для демонстрации перекрытия ожиданий и таймаутов.
REST-эндпойнты POST /orders, GET /orders/{id}. Вставка в orders/tasks в одной транзакции; возвращает идентификатор, не блокируя клиента ожиданием внешних вызовов.
Фан-аут/фан-ин: Pricing, Stock, Delivery. Время ожидания на каждый вызов, маппинг ошибок: 5xx/timeout → retryable, 4xx → non-retryable.
Таблицы orders и tasks (поля status, attempts, next_attempt_at). Реляционная целостность, фиксируем итоговые статусы DONE/FAILED/ERROR.
Эмулирует I/O-задержки и ошибки, чтобы показать поведение пула и ретраев.
Возвращает успех/отказ резервирования; при отказе — завершаем заказ и задачу как ERROR (non-retryable).
Стаб-сервис со случайными задержками для демонстрации перекрытия ожиданий и таймаутов.
Решение: ConcurrentHashMap
Решение: выносить блокировку на минимум
Решение: понимание visibility
При таком способе стоимость курса увеличивается на 10% от текущей. К сожалению, это связано с юридическими издержками на подготовку сделки — работа юристов, договоры, оферта:(
Оставить заявку на оплату
Вот что ты сможешь делать после курса:
- Писать правильный и эффективный многопоточный код для запросов к внешним API, работой с базами данных
- Поймёшь где в настоящих системах встречаются ошибки/проблемы из-за многопоточного кода и сможешь в своём проекте заранее этого не допустить и не выкатить критичных ошибок на прод
- Поймёшь где и как в реальных системах используются и работают потоки, в том числе под капотом внутри библиотек
- Применять современные инструменты многопоточности, такие как: CompletableFuture, ExecutorService и виртуальные потоки
- Поймёшь как работают виртуальные потоки — самое важное обновление за последние годы, и как использовать их в продакшне
- Поймёшь как работает параллельная обработка запросов на backend в SpingBoot
- Работать с современными инструментами типа CompletableFuture и Streams. parallel ()
- Бонус с реальными вопросами по многопоточке на собесах даст тебе ответы на все эти вопросы
- Написание реального проекта поможет понять суть и потрогать все технологии, чтобы ты отвечал на собесе как практик, а не теоретик
❌ Только базовые Thread и synchronized → ✅ Современный стек: ExecutorService, CompletableFuture, ForkJoinPool, parallelstreams, virtual threads Java 21 — и как это работает под капотом
❌ Молчат про грабли и ошибки → ✅ Показываем все способы ошибиться: типичные баги с виртуальными потоками, когда увеличение потоков даёт ноль прироста, какие боттлнеки убивают производительность
❌ Сухая теория из книжек → ✅ Понятные объяснения на аналогиях и примерах от Senior’а из финтеха
Многопоточность в Java: онлайн-курс для разработчиков
Курс по многопоточности в Java в Sorokin School: онлайн-обучение Java concurrency, Threads API, JVM, JMM, ExecutorService, CompletableFuture и Virtual Threads
Курс «Многопоточность в Java» в Sorokin School — онлайн-программа для Java-разработчиков, которые хотят системно разобраться в потоках, параллельном программировании и production-подходах к concurrency. В рамках обучения ты разберешься, как работают процессы и потоки, как JVM управляет исполнением кода, почему порядок выполнения в многопоточной среде недетерминированный и как писать Java-код, который корректно работает под нагрузкой.
Формат обучения подойдет, если ты знаешь базу Java, уже пишешь код и хочешь закрыть один из самых сложных пробелов в backend-разработке — многопоточность. Курс будет полезен начинающим Java-разработчикам, junior-разработчикам, junior/middle backend-разработчикам и тем, кто готовится к собеседованиям на middle+ позиции, где часто спрашивают Threads API, Java Memory Model, synchronized, volatile, locks, deadlock, ExecutorService, CompletableFuture и конкурентные коллекции.
Если ты только начинаешь программировать с нуля и еще не понимаешь базовый синтаксис Java, ООП, коллекции, исключения и основы backend-разработки, курс может быть сложным для старта. Чтобы обучение проходило комфортно, важно уже уметь читать и писать Java-код, понимать базовые конструкции языка и быть готовым регулярно практиковаться. Многопоточность невозможно освоить только просмотром уроков: здесь нужно запускать код, ломать его, видеть race condition, дедлоки, проблемы видимости и исправлять их руками.
Что изучают на курсе по многопоточности Java
Обучение начинается с фундамента: зачем нужна многопоточность, где однопоточность ограничивает систему, как устроены program, process и thread, чем отличается поток от процесса, где у потоков общая память, а где изолированный stack. Отдельно разбираются планировщик операционной системы, состояния Ready, Waiting, Blocked, разница между RUNNABLE и RUNNING, стоимость переключения контекста и причины, по которым порядок выполнения потоков нельзя считать предсказуемым.
В первом модуле курса разбираются базовые инструменты Java: Thread, Runnable, методы start и run, join, sleep, interrupt, восстановление флага прерывания, getState, daemon-потоки и user-потоки. После этого ученик переходит к синхронизации: race condition, mutex, критическая секция, synchronized, volatile, видимость изменений между потоками и первые практические сценарии, где неправильная работа с потоками приводит к ошибкам.
Следующая часть курса посвящена Java Memory Model, happens-before, reordering и межпоточной сигнализации. Ученик разбирает, почему без happens-before порядок операций не гарантирован, чем volatile отличается от synchronized, почему volatile дает видимость и порядок, но не атомарность, как работают wait, notify, notifyAll, монитор, EntryList, WaitList, spurious wakeups и почему условие ожидания нужно проверять через while.
В программе также есть ReentrantLock, Condition, lockInterruptibly, tryLock с timeout, Semaphore, ReadWriteLock, CountDownLatch, атомики, CAS, ABA-проблема, AtomicStampedReference, ThreadLocal и типовые утечки в пулах потоков. Отдельный фокус — deadlock и livelock: как они возникают, как их воспроизвести, как обнаружить, какие условия Коффмана приводят к дедлоку и как использовать порядок захвата локов, timeout, rollback, backoff и разрыв симметрии.
Продвинутый блок курса посвящен ExecutorService, ThreadPoolExecutor, FixedThreadPool, CachedThreadPool, ScheduledThreadPool, SingleThreadExecutor, ForkJoinPool, work-stealing, parallel streams, Runnable, Callable, Future и CompletableFuture. Ученик разбирает цепочки thenApply, thenCompose, thenCombine, allOf, anyOf, обработку ошибок, таймауты, CompletableFuture-агрегацию и сценарии, где асинхронная модель помогает ускорять I/O-bound задачи.
Отдельная часть обучения посвящена конкурентным коллекциям и современным инструментам Java: ConcurrentHashMap, CopyOnWriteArrayList, ArrayBlockingQueue, LinkedBlockingQueue, обычные и виртуальные потоки, Java 21, Project Loom, Thread.ofVirtual, Executors.newVirtualThreadPerTaskExecutor, mapping виртуальных потоков на carrier-потоки, mount и unmount стека, thread pinning, ограничения Virtual Threads и ситуации, где виртуальные потоки дают выигрыш, а где нет.
Практика, домашние задания и production-case Async Runner 2049
Курс построен не как теоретический справочник, а как практическое обучение Java multithreading. Внутри программы есть 15 часов концентрированного контента, визуальные объяснения, много кода и 4 практические домашние задания. Ученик не просто узнает термины, а пишет многопоточный код, запускает потоки, управляет их жизненным циклом, работает с синхронизацией, реализует потокобезопасные структуры, сравнивает разные подходы и видит, где concurrency ломается на практике.
В домашних заданиях ученик проходит путь от базового управления потоками до production-like сценариев. В заданиях разбираются interrupt, daemon-потоки, volatile, synchronized, потокобезопасные счетчики, ReentrantLock, AtomicLong, LongAdder, дедлоки, tryLock с timeout, ExecutorService, CompletableFuture, ConcurrentHashMap, Virtual Threads и асинхронная обработка задач. Такой формат помогает не просто запомнить API, а понять, какой инструмент выбирать под конкретную задачу.
Финальный production-case курса — Async Runner 2049. Это асинхронный процессинг заказов, где сервис принимает заказ, быстро возвращает 201 и taskId, а дальше параллельно вызывает внешние API, агрегирует результат и пишет данные в базу. Внутри проекта используются очередь задач на базе БД, поллер, раннер, CompletableFuture-композиция, retry-логика, таймауты, статусы NEW, IN_PROGRESS, DONE, FAILED, ERROR и сравнение обычного ExecutorService с виртуальными потоками.
Какой результат дает курс по Java multithreading
После прохождения всех модулей курса ты как Java-разработчик сможешь:
- понимать, как устроены потоки, процессы, JVM и планировщик операционной системы;
- создавать, запускать, останавливать и диагностировать потоки через Threads API;
- объяснять race condition, visibility, atomicity, synchronized, volatile и happens-before;
- разбираться в Java Memory Model, reordering и гарантиях выполнения многопоточного кода;
- использовать ReentrantLock, Condition, Semaphore, ReadWriteLock, CountDownLatch и ThreadLocal;
- работать с атомиками, CAS, ABA-проблемой и потокобезопасными счетчиками;
- находить и исправлять deadlock, livelock, lost signals и проблемы синхронизации;
- выбирать между ExecutorService, ForkJoinPool, CompletableFuture, parallel streams и Virtual Threads;
- использовать ConcurrentHashMap, CopyOnWriteArrayList, BlockingQueue и другие concurrent collections;
- проектировать асинхронные сценарии в Spring Boot и понимать ограничения thread-per-request, event-loop и Virtual Threads;
- диагностировать bottleneck, пулы, очереди, rate limiters, HikariCP и узкие места в production-сервисах;
- реализовать production-like проект Async Runner 2049 и использовать его как практический кейс.
Все уроки проходят онлайн. Формат курса рассчитан на самостоятельное прохождение в удобном темпе: ты смотришь видеоуроки, пересматриваешь сложные места, пишешь код, выполняешь домашние задания и постепенно переходишь от базовых потоков к реальным production-сценариям. Для прохождения курса важно закладывать время не только на просмотр уроков, но и на практику, потому что многопоточность в Java становится понятной только через код, ошибки, отладку и повторение.
Курс по многопоточности Java подойдет тем, кто хочет закрыть сложную тему для собеседований и работы, перестать бояться concurrency-вопросов, увереннее проходить технические интервью, лучше понимать backend-системы и брать задачи, связанные с асинхронностью, параллельной обработкой, производительностью, нагрузкой, очередями, пулами потоков и взаимодействием сервисов.
Программа не обещает автоматическое трудоустройство, но помогает усилить техническую базу, подготовиться к вопросам по Java multithreading, concurrency и JVM, собрать практический production-case, глубже понять работу Spring Boot-сервисов и увереннее претендовать на позиции junior+, junior/middle или middle Java backend developer в зависимости от текущего опыта и уровня подготовки.
Если ты сомневаешься, подойдет ли тебе курс по многопоточности в Java, можно оставить заявку на сайте и задать вопрос команде Sorokin School. Мы поможем разобраться с программой, уровнем входа, форматом обучения, домашними заданиями, тарифами, практикой, финальным проектом Async Runner 2049 и темами, которые стоит подтянуть до старта курса.
Для компаний и команд также может быть актуально корпоративное обучение Java multithreading. Онлайн-формат подходит для повышения квалификации Java-разработчиков, систематизации знаний по JVM, Java Memory Model, ExecutorService, CompletableFuture, Virtual Threads, Spring Boot, асинхронной обработке, потокобезопасности и production-подходам к backend-разработке.
Оставляя заявку на сайте, вы даете согласие на обработку персональных данных согласно Политике конфиденциальности, а также соглашаетесь с условиями Договора оферты и Согласием на получение рассылки.
Многопоточность в Java онлайн-курс для разработчиков