🧵 Раздел 9 · 27 вопросов
Многопоточность
27 вопросов и ответов в разделе Многопоточность.
Вопросы этого раздела
- В чём разница между synchronized и volatile
- Что такое happens-before relationship
- Что такое visibility problem
- Что такое монитор (monitor) в Java
- Как работает synchronized на уровне монитора
- В чём разница между synchronized методом и synchronized блоком
- Что такое reentrant lock
- Что такое Atomic классы
- Что такое CAS (Compare-And-Swap)
- Как работают AtomicInteger, AtomicLong
- В чём преимущество Atomic классов перед synchronized
- Что такое пул потоков (Thread Pool)
- Какие типы Thread Pool существуют в Java
- Что делает ExecutorService
- В чём разница между Executors.newFixedThreadPool() и newCachedThreadPool()
- Что такое ForkJoinPool
- Что такое deadlock (взаимная блокировка)
- Какие условия необходимы для возникновения deadlock
- Как предотвратить deadlock
- Что такое race condition
- Как избежать race condition
- Что такое Virtual Threads в Java 21
- В чём преимущества Virtual Threads перед обычными потоками
- Когда стоит использовать Virtual Threads
- Что такое structured concurrency
- В чём разница между Thread и Runnable
- Что такое Callable и Future
Навигатор по разделу
📋 Все вопросы
🗺️ Карта зависимостей тем
┌──────────────────────────────────────────┐
│ FUNDAMENTALS (1-3) │
│ 1. synchronized vs volatile │
│ 2. happens-before │
│ 3. visibility problem │
└──────────────────┬───────────────────────┘
│
┌──────────────────────────┼──────────────────────────┐
▼ ▼ ▼
┌───────────────┐ ┌───────────────┐ ┌────────────────────┐
│ MONITORS │ │ LOCK-FREE │ │ PROBLEMS │
│ & LOCKS (4-7) │ │ (8-11) │ │ (18-22) │
│ 4. Monitor │ │ 8. Atomic │ │ 18. Deadlock │
│ 5. synchronized│ │ 9. CAS │ │ 19. Coffman cond. │
│ internals │ │ 10. AtomicInteger│ │ 20. Prevention │
│ 6. method vs │ │ AtomicLong │ │ 21. Race condition │
│ block │ │ 11. vs sync │ │ 22. Avoidance │
│ 7. Reentrant │ │ │ │ │
│ Lock │ │ │ │ │
└───────┬───────┘ └───────┬───────┘ └────────┬───────────┘
│ │ │
└────────────────────────┼────────────────────────┘
▼
┌──────────────────────────────────────────┐
│ THREAD POOLS (12-17) │
│ 12. Thread Pool (концепция) │
│ 13. Типы пулов │
│ 15. ExecutorService │
│ 16. Fixed vs Cached │
│ 17. ForkJoinPool │
└──────────────────────────────────────────┘
│
┌────────────────────────┼────────────────────────┐
▼ ▼ ▼
┌───────────────┐ ┌───────────────┐ ┌────────────────────┐
│ JAVA 21+ │ │ ОСНОВЫ │ │ │
│ (23-26) │ │ (27-28) │ │ │
│ 23. Virtual │ │ 27. Thread vs │ │ │
│ Threads │ │ Runnable │ │ │
│ 24. Преимущества│ │ 28. Callable │ │ │
│ 25. Когда │ │ и Future │ │ │
│ 26. Structured │ │ │ │ │
│ Concurrency│ │ │ │ │
└───────────────┘ └───────────────┘ └────────────────────┘
🎯 Рекомендуемый порядок изучения
🟢 Уровень Junior (недели 1-2)
| Шаг | Тема | Файлы | Цель |
|---|---|---|---|
| 1 | Основы | Q1, Q3 | synchronized vs volatile, visibility problem |
| 2 | Мониторы | Q4, Q6 | Что такое монитор, метод vs блок |
| 3 | Thread и Runnable | Q27, Q28 | Thread vs Runnable, Callable и Future |
| 4 | Deadlock базовый | Q18 | Что такое, примеры |
| 5 | Race condition базовый | Q21, Q22 | Что такое, как избежать |
🟡 Уровень Middle (недели 3-4)
| Шаг | Тема | Файлы | Цель |
|---|---|---|---|
| 1 | happens-before | Q2 | 8 правил JMM, программа, volatile, start/join |
| 2 | Мониторы глубже | Q5 | Эволюция состояний, thin/fat lock, JIT |
| 3 | ReentrantLock | Q7 | AQS, fair vs non-fair, Condition |
| 4 | CAS и Atomic | Q8, Q9, Q10 | CAS-цикл, ABA, VarHandle, Atomic* |
| 5 | Thread Pools | Q12, Q13, Q15, Q16 | Типы пулов, ExecutorService, sizing |
| 6 | Deadlock глубже | Q19, Q20 | Условия Коффмана, lock ordering, tryLock |
| 7 | ForkJoinPool | Q17 | Work-stealing, recursive tasks |
🔴 Уровень Senior (недели 5-6)
| Шаг | Тема | Файлы | Цель |
|---|---|---|---|
| 1 | synchronized internals | Q5 (Senior) | Mark Word, CAS spin, inflation, elision |
| 2 | CAS internals | Q9 (Senior) | lock cmpxchg, memory barriers, progress guarantees |
| 3 | Virtual Threads | Q23, Q24, Q25 | StackChunk, carrier threads, pinning, unmount |
| 4 | Structured Concurrency | Q26 | ShutdownOnFailure/Success, scope lifetime |
| 5 | Atomic vs Lock perf | Q11 (Senior) | Break-even point, contention curves |
| 6 | Race conditions | Q21, Q22 (Senior) | Heisenbugs, safe publication, ThreadLocal |
| 7 | ThreadPool tuning | Q12-Q16 (Senior) | Sizing formulas, rejection policies, monitoring |
🔗 Ключевые связи между темами
Тема: Синхронизация
Q1 (synchronized vs volatile) → Q4 (Monitor) → Q5 (synchronized internals)
↓ ↓ ↓
Q3 (Visibility) Q6 (method vs block) Q7 (ReentrantLock)
Ключевые связи:
- Q1 ↔ Q3: volatile решает visibility problem, но НЕ атомарность
- Q4 ↔ Q5: монитор — концепция, synchronized — реализация
- Q5 ↔ Q7: synchronized → ReentrantLock (эволюция от языкового к библиотечному)
- Q6 ↔ Q7: synchronized блок = ReentrantLock.lock/unlock
Тема: Lock-Free
Q9 (CAS) → Q8 (Atomic классы) → Q10 (AtomicInteger/Long)
↓ ↓
└──────────────────────→ Q11 (vs synchronized)
Ключевые связи:
- Q9 ↔ Q10: AtomicInteger = обёртка над CAS
- Q8 ↔ Q11: Atomic vs synchronized — optimistic vs pessimistic подход
- Q9 ↔ Q18: CAS предотвращает deadlock (нет блокировки), но не race condition
Тема: Проблемы многопоточности
Q18 (Deadlock) → Q19 (Coffman conditions) → Q20 (Prevention)
Q21 (Race condition) → Q22 (Avoidance)
Ключевые связи:
- Q18 ↔ Q21: Deadlock = потоки ждут друг друга, Race = результат зависит от порядка
- Q19 ↔ Q20: Нарушь одно условие Коффмана → deadlock невозможен
- Q21 ↔ Q3: Race condition часто вызван visibility problem
Тема: Пулы потоков
Q12 (Thread Pool) → Q13 (Типы) → Q15 (ExecutorService)
↓ ↓ ↓
Q16 (Fixed vs Cached) Q17 (ForkJoin) Q16 (сравнение)
Ключевые связи:
- Q12 ↔ Q13: Концепция пула → конкретные реализации
- Q15 ↔ Q16: ExecutorService → конкретные фабрики (Fixed, Cached)
- Q17 ↔ Q13: ForkJoinPool = WorkStealingPool для divide-and-conquer
Тема: Java 21+ (Будущее)
Q23 (Virtual Threads) → Q24 (Преимущества) → Q25 (Когда использовать)
↓
Q26 (Structured Concurrency)
Ключевые связи:
- Q23 ↔ Q24: Архитектура VT → почему дешевле платформенных потоков
- Q23 ↔ Q13: VT заменяет CachedThreadPool для I/O-bound задач
- Q25 ↔ Q12: VT НЕ заменяет Thread Pool для CPU-bound задач
- Q26 ↔ Q15: StructuredTaskScope заменяет ExecutorService для структурированных задач
🎓 Шпаргалка: что знать для каждого уровня
🟢 Junior
- synchronized = блокировка, volatile = видимость
- Thread создаётся через Runnable (композиция, не наследование)
- Callable возвращает результат, Runnable — нет
- Deadlock = два потока ждут друг друга навсегда
- Race condition = результат зависит от порядка выполнения потоков
- Thread Pool переиспользует потоки, экономит память и время
🟡 Middle
- happens-before: program order, volatile, monitor, start/join, transitivity
- Монитор: No Lock → Thin Lock → Fat Lock, Mark Word, ObjectMonitor
- ReentrantLock: AQS, fair vs non-fair, Condition (wait/notify аналог)
- CAS: optimistic подход, retry cycle, ABA проблема → AtomicStampedReference
- Thread Pool: Fixed (известная нагрузка), Cached (короткие задачи), Scheduled (периодические)
- Deadlock prevention: lock ordering, tryLock(timeout), один lock
- AtomicInteger: CAS-цикл, lazySet, LongAdder для высокой конкуренции
🔴 Senior
- synchronized internals: biased (удалён в Java 21), thin (CAS spin), fat (OS park)
- JIT: lock elision (escape analysis), lock coarsening
- CAS: lock cmpxchg (x86), memory barriers, progress guarantees (wait-free > lock-free > obstruction-free)
- Virtual Threads: StackChunk, carrier threads, unmount при I/O, pinning (synchronized блокирует carrier!)
- Structured Concurrency: ShutdownOnFailure/Success, scope lifetime, preview API
- ThreadPool sizing: CPU-bound = cores + 1, I/O-bound = cores × (1 + W/S)
- ForkJoinPool: work-stealing deque, LIFO для владельца/FIFO для вора, commonPool dangers
📝 Формат каждого файла
Каждый файл содержит:
- 🟢 Junior Level — базовое понимание, простые аналогии, примеры
- 🟡 Middle Level — внутренности, типичные ошибки, практические примеры
- 🔴 Senior Level — deep dive, edge cases, production experience, monitoring
- 🎯 Шпаргалка для интервью — ключевые тезисы, частые вопросы, красные флаги, связанные темы