Багатопоточність

Питання цього розділу

Навігатор по розділу

27 запитань для підготовки до співбесіди на Middle/Senior Java Developer.

📋 Усі запитання

#	Запитання	Рівень складності
1	В чому різниця між synchronized та volatile	⭐⭐
2	Що таке happens-before relationship	⭐⭐⭐
3	Що таке visibility problem	⭐⭐
4	Що таке монітор (monitor) в Java	⭐⭐
5	Як працює synchronized на рівні монітора	⭐⭐⭐
6	В чому різниця між synchronized методом та synchronized блоком	⭐⭐
7	Що таке reentrant lock	⭐⭐
8	Що таке Atomic класи	⭐⭐
9	Що таке CAS (Compare-And-Swap)	⭐⭐⭐
10	Як працюють AtomicInteger, AtomicLong	⭐⭐
11	В чому перевага Atomic класів перед synchronized	⭐⭐
12	Що таке пул потоків (Thread Pool)	⭐⭐
13	Які типи Thread Pool існують в Java	⭐⭐
15	Що робить ExecutorService	⭐⭐
16	В чому різниця між Executors.newFixedThreadPool() та newCachedThreadPool()	⭐⭐
17	Що таке ForkJoinPool	⭐⭐⭐
18	Що таке deadlock (взаємне блокування)	⭐⭐
19	Які умови необхідні для виникнення deadlock	⭐⭐⭐
20	Як запобігти deadlock	⭐⭐⭐
21	Що таке race condition	⭐⭐
22	Як уникнути race condition	⭐⭐
23	Що таке Virtual Threads в Java 21	⭐⭐⭐
24	В чому переваги Virtual Threads перед звичайними потоками	⭐⭐⭐
25	Коли варто використовувати Virtual Threads	⭐⭐
26	Що таке structured concurrency	⭐⭐⭐
27	В чому різниця між Thread та Runnable	⭐
28	Що таке 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
🎯 Шпаргалка для співбесіди — ключові тези, часті запитання, червоні прапори, пов’язані теми