Коротко и по существу — принципы, ошибки, практические паттерны.
Что важно понять (Java Memory Model, happens-before)
- Операции упорядочены по правилам happens-before. Если операция A happens-before операции B, то видимые эффекты A будут видны в B.
- Механизмы, дающие happens-before: вход/выход из монитора (synchronized), запись/чтение volatile, старт/join потоков, финальные поля при правильной публикации, операции из java.util.concurrent.
synchronized (мониторы)
- Что делает: обеспечивает взаимное исключение (монитор одного объекта) и гарантирует видимость: освобождение монитора -> последующее захватывание этого же монитора наблюдает все изменения.
- Формы: синхронизированный метод или блок: `synchronized(obj) { ... }`.
- Особенности: reentrant (можно повторно захватить), блокирует поток пока он владеет монитором; wait/notify работают с монитором.
- Ограничения: может приводить к блокировкам/калечащей конкуренции при большой конкуренции; нельзя прервать блокировку внутри `synchronized`.
volatile
- Что делает: гарантирует видимость и запретит реорганизацию относительно volatile-записи/чтения: запись в volatile happens-before последующего чтения того же volatile.
- Не даёт взаимного исключения — операции над volatile не атомарны, если это составные операции (например, `x = x + 1`).
- Подходит для флагов состояния, lazy-проверок с корректной синхронизацией, безопасной публикации примитивов/ссылок.
java.util.concurrent (высокоуровневые примитивы)
- Классы: Lock/ReentrantLock (tryLock, fairness), ReadWriteLock, Atomic* (AtomicInteger, AtomicReference) — CAS-операции, ConcurrentHashMap, CopyOnWriteArrayList, BlockingQueue, Executors, CountDownLatch, Semaphore и т.д.
- Преимущества: более гибкое управление (тайм-ауты, прерываемость), неблокирующие алгоритмы (атомики) для производительности и избежания классических ошибок.
Типичные ошибки синхронизации и предотвращение
Deadlock (взаимная блокировка)
- Причина: циклическое ожидание ресурсов (A удерживает L1 и ждёт L2; B удержит L2 и ждёт L1).
- Симптомы: поток(и) навсегда заблокированы.
- Предотвращение (паттерны):
- Определённый порядок захвата замков (все потоки всегда захватывают locks в одном порядке).
- Минимизировать время удержания замков, не выполнять блокирующие/IO операции под замком.
- Использовать `tryLock` с таймаутом (и откат при неудаче).
- Сведение количества разных замков к минимуму; использовать один общий замок или высокоуровневые структуры (ConcurrentHashMap).
- Избегать вложенных синхронизированных блоков или документировать и централизовать политику блокировок.
Race condition (гонка за состояние / нарушенная атомарность)
- Причина: несколько потоков одновременно читают/пишут состояние без синхронизации; небезопасные check-then-act.
- Примеры: некорректное инкрементирование счётчика без синхронизации.
- Предотвращение:
- Делать операции атомарными: использовать synchronized/Locks или Atomic* (CAS) для одношаговых изменений.
- Использовать высокоуровневые структуры (например, ConcurrentMap вместо HashMap + синхронизация).
- Применять иммутабельность и безопасную публикацию (final поля + корректная ссылка публикации).
- Конфинемент: держать данные внутри единственного потока или ThreadLocal, если возможно.
Visibility (видимость обновлений)
- Причина: кэширование регистров/реорганизация инструкций, поток не видит изменения, сделанные другим потоком.
- Симптомы: флаг изменился в одном потоке, другие никогда не замечают.
- Предотвращение:
- Использовать volatile для флагов/переменных, где требуется простая видимость.
- Использовать synchronized/Locks — они обеспечивают видимость при входе/выходе из монитора.
- Использовать классы из java.util.concurrent (обеспечивают нужные барьеры).
- Правильная публикация объектов (инициализация -> установка ссылки в volatile или через синхронизацию).
Практические шаблоны и рекомендации
- Предпочитайте высокоуровневые примитивы (Executors, Concurrent Collections) вместо ручной синхронизации.
- Минимизируйте область критических секций: синхронизируйте только то, что необходимо.
- Документируйте, какая переменная под каким замком ("guarded by").
- Для счётчиков/флагов: используйте AtomicInteger/AtomicBoolean или volatile + атомарные методы.
- Для сложных операций, где нужно блокирование с таймаутом/прерываемостью — используйте ReentrantLock и tryLock(timeout).
- Для частых чтений и редких записей — ReadWriteLock или CopyOnWriteArrayList.
- Сделайте объекты иммутабельными, где возможно — это исключает многие проблемы видимости и гонки.
- Тестируйте многопоточные сценарии: статический анализ, инструменты (FindBugs/SpotBugs), Thread sanitizer, стресс-тесты, unit-тесты с моделированием конкуренции.
- Простая эвристика: если вы не уверены в корректности ручной синхронизации — замените на java.util.concurrent эквивалент.
Короткие примеры (идеи)
- Синхронизация:
- synchronized используется для атомарных критических секций.
- Volatile для флага:
- `volatile boolean stop = false; // один поток ставит true, другие читают`
- Atomic для счётчика:
- `AtomicInteger counter = new AtomicInteger(); counter.incrementAndGet();`
- TryLock для избежания deadlock:
- `if (lock.tryLock()) { try { ... } finally { lock.unlock(); } } else { /* откат/повтор */ }`
Заключение
- Понимайте happens-before. Используйте volatile для видимости, synchronized/Lock для атомарности и видимости, и java.util.concurrent для более безопасных и производительных решений. Применяйте паттерны: порядок захвата замков, минимизация критических секций, иммутабельность, confinement и использование высокоуровневых конструкций.
Если нужно, могу привести компактные код-примеры для конкретных сценариев (atomic counter, предотвращение deadlock через порядок захвата, корректная публикация объекта).