0Корзина Закладки0

Павел Сорокин - Многопоточность в Java. Тариф Стандарт

Павел Сорокин

Павел Сорокин - Многопоточность в Java. Тариф Стандарт
✅ Лучшее качество
О версии курса

Материал без водяных знаков.

2 720,00 ₽

Пришлите ссылку — проверим предложение и ответим на почту.

Артикул: 20376
Подробности о материале
Артикул: 20376 В наличии Автор курса: Павел Сорокин Категория: Программирование Продажник от автора: Перейти
Разберись в потоках от фундамента до production-кода.
Будешь спокойно писать многопоточные приложения, проходить собесы на middle+ без страха и сможешь претендовать на вакансии с зарплатой в 2 раза выше.
Для кого этот курс:
Новичок, знающий только базу по 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 (массив против связного 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‑сценариях (десятки тысяч задач) и сделать обоснованный выбор
Модуль 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 — где рождаются «бутылочные горлышки» в реальных прод-сервисах и как их диагностировать и предотвратить
  • План деградации и изоляция ресурсов — как защитить систему, если одно из 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+».
    • Реальные вопросы с собесов
    • Как объяснять сложные темы простым языком
    • Какие примеры приводить, чтобы выглядеть убедительно
    • Как вести себя, если не знаешь ответа (спойлер: это нормально)
    • Разбор типичных «ловушек» в вопросах интервьюеров
  • Это как репетиция интервью — после просмотра ты будешь звучать уверенно.
Автор Паша Сорокин (S0R0KlN) — Java backend-разработчик и контент-мейкер, ведущий YouTube-канал и Telegram-канал об IT. Он специализируется на Java-разработке, микросервисах, а также проводит mock-собеседования для помощи в трудоустройстве

Тариф Стандарт
  • 4 модуля курса (15 часов видео)
  • 4 практические домашки (от простых к продакшн-кейсу)
  • Реальный проект для портфолио — обработчик очереди задач
  • Чек-лист «20 ошибок в многопоточности»

Перед покупкой на Sklads

Проверьте выбранную версию «Павел Сорокин - Многопоточность в Java. Тариф Стандарт» и состав материала. Автор: Павел Сорокин. Описание и скриншоты помогут понять, подходит ли курс для вашей задачи.

Вопросы о содержимом можно уточнить у поддержки. Покупки и доступные заявки на обновление находятся в личном кабинете.

Сравнение вариантов материала «Павел Сорокин - Многопоточность в Java. Тариф Стандарт»

В каталоге SKLADS.NET этот материал находится в рубрике «Программирование». При выборе ориентируйтесь на состав программы и конкретный тариф, а не только на название. В карточке указан автор: Павел Сорокин.

Вариант отмечен как материал без водяных знаков и относится к «Лучшему качеству». Эта характеристика не заменяет проверку названия тарифа и состава файлов.

Стоимость выбранной версии на Sklads смотрите в блоке покупки.

Есть вопрос о курсе?

Поможем разобраться с версией и составом материала

Написать в поддержку
Помощь и отзывы

💬 Помощь перед покупкой

Хотите проверить материал?
Отправим дополнительные скриншоты, пример видео или запись содержимого курса.

💰 Нашли дешевле?
Пришлите ссылку на предложение — постараемся сделать цену ещё выгоднее.

⭐ Отзывы покупателей
Читать отзывы на сайте
Читать отзывы в Telegram

💬 Связаться с поддержкой
Написать в Telegram
admin@sklads.net

ПОКУПКА И ДОСТУП

Вопросы и ответы

Как выбрать материал и получить доступ после оплаты

Как купить курс на Sklads?

Добавьте материал в корзину или нажмите «Купить». Укажите действующий e-mail и выберите доступный способ оплаты. После подтверждения платежа на эту почту придёт информация о заказе и доступе.

В одном заказе можно купить несколько материалов.

Что входит в курс и есть ли обратная связь?

Состав, версия и формат доступа указаны в карточке. Обычно это запись курса и сопутствующие файлы для самостоятельного обучения. Обратная связь автора не входит, если в описании не указано иное.

Если хотите уточнить содержимое до покупки, напишите в поддержку.

Где смотреть материалы и можно ли их скачать?

Ссылка или инструкция придёт после оплаты. Возможность просмотра онлайн и скачивания зависит от хранилища и формата файлов. Рекомендуем сохранить доступные материалы себе.

Оплата прошла, а письмо не пришло. Что делать?

Проверьте папки «Спам» и «Промоакции», а также адрес, указанный при покупке. Для авторизованного аккаунта проверьте раздел «Мои заказы».

Если доступа нет, отправьте в поддержку номер заказа, e-mail и подтверждение платежа — поможем найти покупку.

Как использовать бонусы?

Бонусы доступны в аккаунте. Размер начисления за этот курс указан рядом с покупкой. При оформлении заказа можно применить доступный бонусный баланс: 1 бонус соответствует 1 рублю.

Итоговую сумму и списание проверьте в корзине перед оплатой.

Как получить цену ниже?

Нажмите «Нашли дешевле?» рядом с ценой курса, пришлите ссылку, цену и e-mail. Мы сравним предложения и сообщим решение на почту. Если заявку одобрят, в письме будет персональная цена и срок её действия.

При покупке по персональной цене используйте почту из заявки.

Что делать, если ссылка на материал перестала работать?

Откройте покупку в разделе «Мои заказы». Если для неё доступен запрос обновления, отправьте его. Либо свяжитесь с поддержкой, указав номер заказа и название курса.

Где посмотреть условия возврата?

Условия описаны на странице «Условия возврата». Если возникла проблема с оплаченной покупкой, напишите в поддержку с номером заказа и описанием ситуации.

Главная » Программирование » Павел Сорокин - Многопоточность в Java. Тариф Стандарт