⚛️ Lock, атомики и CAS
synchronized закрывает большую часть задач, но не умеет ждать блокировку с таймаутом, прерываться в очереди и держать несколько условий ожидания. Для этого в java.util.concurrent.locks есть ReentrantLock и его родня, а для счётчиков и флагов — атомики на CAS, которые обходятся без блокировок совсем. Интервьюеры обычно проверяют, чем ReentrantLock отличается от synchronized, как устроен CAS, когда брать LongAdder и почему ThreadLocal в пуле надо чистить
🔒 ReentrantLock
Чем отличается от synchronized
Оба взаимоисключающие и реентерабельные: поток, который уже держит блокировку, может взять её ещё раз, счётчик захватов растёт, и отпустить нужно столько же раз. Видимость изменений тоже одинаковая: unlock для следующего lock работает как выход из монитора для входа, правила видимости разобраны на странице про JMM, synchronized и volatile
synchronized | ReentrantLock | |
|---|---|---|
| Освобождение | Само при выходе из блока, даже по исключению | Вручную, unlock() в finally |
| Ждать с таймаутом | Нет | tryLock(timeout, unit) |
| Прервать ожидание | Нет, поток в BLOCKED не реагирует на interrupt | lockInterruptibly() |
| Условия ожидания | Одно: wait/notify на мониторе | Сколько угодно Condition |
| Честная очередь | Нет | new ReentrantLock(true) |
Правило по умолчанию: пиши synchronized, пока не нужна одна из возможностей справа. Он короче, и забыть его отпустить нельзя
Шаблон lock и unlock
private final ReentrantLock lock = new ReentrantLock();
void transfer() {
lock.lock(); // до try: если lock() бросит, unlock() звать не надо
try {
// критическая секция
} finally {
lock.unlock(); // снимется и при исключении
}
}lock() ставят перед try, а не внутри. Если захват упадёт внутри try, finally вызовет unlock() на чужой блокировке и получит IllegalMonitorStateException, которое спрячет настоящую ошибку
tryLock и lockInterruptibly
tryLock() без аргументов берёт блокировку, только если она свободна прямо сейчас. tryLock(100, MILLISECONDS) ждёт не дольше таймаута и возвращает false. Так выходят из deadlock: поток не висит вечно, а отпускает то, что уже взял, и пробует снова или отвечает ошибкой. Как deadlock возникает и как его найти в jstack, разобрано на странице про JMM
if (from.lock.tryLock(100, TimeUnit.MILLISECONDS)) {
try {
if (to.lock.tryLock(100, TimeUnit.MILLISECONDS)) {
try {
move(from, to, amount);
return true;
} finally { to.lock.unlock(); }
}
} finally { from.lock.unlock(); }
}
return false; // не вышло — отпустили всё, можно повторить с паузойlockInterruptibly() встаёт в очередь, но выходит из неё с InterruptedException, если поток прервали. Так отменённая задача, например после shutdownNow() пула, не останется ждать блокировку вечно. Поток в synchronized так не умеет, он стоит в BLOCKED до победного
Fairness и её цена
По умолчанию ReentrantLock нечестный: только что пришедший поток может перехватить блокировку раньше тех, кто давно ждёт в очереди. Честный режим new ReentrantLock(true) отдаёт её самому старому ожидающему
На 8 потоках, которые увеличивают счётчик под блокировкой, честная оказалась медленнее на два порядка: каждая передача блокировки будит другой поток через планировщик ОС, а нечестная чаще достаётся потоку, который уже бежит на ядре. Честность нужна, когда голодание потока — реальная проблема, а не на всякий случай. Нюанс: tryLock() без таймаута игнорирует честность и захватывает свободную блокировку вне очереди
Condition и ограниченный буфер
У монитора одно множество ожидания, и notifyAll() будит всех: и производителей, и потребителей. ReentrantLock выдаёт несколько Condition, и каждое условие будит только своих. В ограниченном буфере это два условия: «есть место» и «есть элемент»
Java · Ограниченный буфер на двух Condition
class BoundedBuffer<T> {
private final Object[] items;
private int putIdx, takeIdx, count;
private final ReentrantLock lock = new ReentrantLock();
private final Condition notFull = lock.newCondition();
private final Condition notEmpty = lock.newCondition();
BoundedBuffer(int capacity) { items = new Object[capacity]; }
void put(T x) throws InterruptedException {
lock.lock();
try {
while (count == items.length) notFull.await(); // while, не if: ложные пробуждения
items[putIdx] = x;
putIdx = (putIdx + 1) % items.length;
count++;
notEmpty.signal(); // будим только потребителя
} finally { lock.unlock(); }
}
@SuppressWarnings("unchecked")
T take() throws InterruptedException {
lock.lock();
try {
while (count == 0) notEmpty.await();
T x = (T) items[takeIdx];
items[takeIdx] = null;
takeIdx = (takeIdx + 1) % items.length;
count--;
notFull.signal(); // будим только производителя
return x;
} finally { lock.unlock(); }
}
}await() отпускает блокировку и усыпляет поток, при пробуждении захватывает её снова. Проверка условия идёт в while по той же причине, что и с wait. Так устроен ArrayBlockingQueue в JDK, и в работе берут его, а не пишут свой. Про BlockingQueue и producer-consumer — на странице про потокобезопасные коллекции
📖 ReadWriteLock и StampedLock
ReentrantReadWriteLock держит две блокировки: читать могут сколько угодно потоков одновременно, писать — только один и только когда читателей нет. Выглядит как бесплатное ускорение для кэша, который читают чаще, чем пишут, но это не так
Выигрыш есть, когда чтение долгое, а записей мало. Если под блокировкой один map.get, каждый вход читателя всё равно делает CAS на общем счётчике читателей, и все ядра дерутся за одну строку кэша. В замере на 8 потоках с одним get под блокировкой ReentrantReadWriteLock оказался примерно в десять раз медленнее обычного ReentrantLock. Когда под блокировкой обходили тысячу элементов, он был быстрее примерно вдвое. Для мапы из многих потоков обычно хватает ConcurrentHashMap без всякой блокировки
Ещё два ограничения: блокировку чтения нельзя повысить до записи, writeLock().tryLock() при взятом readLock вернёт false, а lock() повиснет навсегда. Понизить запись до чтения можно: взять readLock, потом отпустить writeLock
StampedLock (с Java 8) добавляет оптимистичное чтение. tryOptimisticRead() ничего не блокирует, а только возвращает штамп. Поток читает поля в локальные переменные и спрашивает validate(stamp): если за это время никто не писал, прочитанное годится. Если писали, читаем заново под настоящей блокировкой чтения
long stamp = sl.tryOptimisticRead();
double cx = x, cy = y; // читаем без блокировки
if (!sl.validate(stamp)) { // кто-то писал — перечитываем честно
stamp = sl.readLock();
try { cx = x; cy = y; } finally { sl.unlockRead(stamp); }
}
return Math.hypot(cx, cy);Плата за скорость: StampedLock не реентерабельный. Повторный writeLock() в том же потоке повиснет навсегда, tryWriteLock() в этой ситуации возвращает 0. Ещё у него нет Condition, а в оптимистичной ветке можно увидеть несогласованные поля, поэтому до validate по ним ничего не решают
⚛️ Атомики и CAS
Как работает CAS
CAS (compare-and-swap) — инструкция процессора, которая атомарно делает «если в ячейке лежит expected, запиши new и верни успех, иначе ничего не меняй». На x86 это lock cmpxchg. AtomicInteger.compareAndSet(expected, new) превращается ровно в неё
Всё остальное строится CAS-циклом: прочитать текущее значение, посчитать новое, попробовать записать, а если кто-то успел раньше — повторить:
AtomicInteger counter = new AtomicInteger();
int incrementByHand() {
while (true) {
int current = counter.get();
int next = current + 1;
if (counter.compareAndSet(current, next)) return next;
// другой поток обогнал — читаем заново
}
}Готовые методы: incrementAndGet() возвращает новое значение, getAndIncrement() старое, updateAndGet(x -> x * 2) и accumulateAndGet(3, Math::max) принимают функцию и крутят тот же цикл. Функцию могут вызвать несколько раз, если CAS не прошёл, поэтому в ней не должно быть побочных эффектов: ни логов, ни записи в базу
Почему это без блокировок
Поток, у которого CAS не прошёл, не засыпает и не ждёт, а сразу пробует снова. Никто ничего не держит, поэтому lock-free алгоритм не встанет, если поток с «блокировкой» вытеснили или он упал: держателя просто нет
Цена появляется под сильной конкуренцией. Когда десятки потоков бьют в одну переменную, большая часть CAS проваливается, потоки крутятся вхолостую и гоняют строку кэша между ядрами. Для одной переменной атомик почти всегда быстрее блокировки. Для инварианта из двух полей одного атомика мало: два отдельных AtomicInteger не обновить атомарно вместе
ABA и AtomicStampedReference
CAS сравнивает только значение. Поток прочитал A, задумался, а за это время другой поток поменял A на B и обратно на A. CAS первого потока пройдёт, хотя состояние за его спиной менялось. Для счётчика это неважно, для lock-free стека на ссылках — баг: узел A мог быть снят, переиспользован и вернуться с другим next
AtomicStampedReference хранит пару «ссылка + номер версии» и сравнивает обе части. После A → B → A версия выросла на два, и compareAndSet(seen, "C", oldStamp, oldStamp + 1) вернёт false. AtomicMarkableReference — то же с одним булевым флагом вместо номера
➕ LongAdder под высокой конкуренцией
AtomicLong — одна ячейка памяти, за которую дерутся все ядра. LongAdder раскладывает счёт по нескольким: есть поле base и массив ячеек cells. Пока конкуренции нет, все прибавляют в base через CAS. Как только CAS начинает проваливаться, появляются ячейки, каждый поток пишет в свою по хэшу потока, а массив растёт до числа процессоров. Ячейки помечены @Contended, чтобы соседние не попадали в одну строку кэша
sum() складывает base и все ячейки. Это не атомарный снимок: если в момент подсчёта кто-то прибавляет, сумма может этого ещё не учесть. Для метрик и статистики так и надо, для выдачи уникальных номеров нет: у LongAdder и нет метода вида incrementAndGet, который вернул бы новое значение
Java · Замер AtomicLong против LongAdder
static long run(int threads, Runnable inc) throws Exception {
ExecutorService pool = Executors.newFixedThreadPool(threads);
CountDownLatch done = new CountDownLatch(threads);
long t0 = System.nanoTime();
for (int i = 0; i < threads; i++) pool.submit(() -> {
for (int j = 0; j < 10_000_000; j++) inc.run();
done.countDown();
});
done.await();
pool.shutdown();
return (System.nanoTime() - t0) / 1_000_000;
}
AtomicLong al = new AtomicLong();
LongAdder la = new LongAdder();
System.out.println("AtomicLong " + run(8, al::incrementAndGet) + " ms");
System.out.println("LongAdder " + run(8, la::increment) + " ms, sum " + la.sum());На JDK 19, 8 ядер, 8 потоков по 10 млн инкрементов LongAdder оказался быстрее больше чем на порядок, сумма в обоих случаях ровно 80 млн. В одном потоке разницы не было. Это совпадает с javadoc: при низкой конкуренции классы ведут себя одинаково, при высокой LongAdder выигрывает за счёт памяти под ячейки. Для частых сумм по ключам есть LongAccumulator с произвольной функцией и связка ConcurrentHashMap<K, LongAdder>
🧵 ThreadLocal
Как устроен
ThreadLocal хранит у каждого потока свою копию значения, но лежит она не в самом ThreadLocal. У каждого объекта Thread есть поле threadLocals типа ThreadLocalMap: маленькая хэш-таблица с открытой адресацией. Ключом в ней служит сам объект ThreadLocal, значением — твоё. tl.get() берёт текущий поток, достаёт его карту и ищет в ней себя
Ключ в карте слабая ссылка на ThreadLocal, значение — обычная, сильная. Если на ThreadLocal больше никто не ссылается, GC соберёт ключ, а запись останется с null вместо ключа. Такие записи карта вычищает попутно при get, set и remove, но только если их зовут. Значение при этом живёт столько, сколько поток. В пуле это вся жизнь приложения, отсюда утечка, которая разобрана на странице «Утечки памяти и диагностика»
Где применяют
- Непотокобезопасный объект, который дорого создавать. Классика —
SimpleDateFormat: внутри у него изменяемыйCalendar, и общий экземпляр из нескольких потоков выдаёт кривые даты.ThreadLocal.withInitial(() -> new SimpleDateFormat(...))даёт каждому потоку свой. В новом коде проще взять неизменяемыйDateTimeFormatter - Контекст запроса. MDC в логерах (traceId в каждой строке лога),
SecurityContextHolderв Spring Security по умолчанию —ThreadLocal. Фильтр кладёт значение в начале запроса и снимает в конце - Транзакция в Spring.
TransactionSynchronizationManagerдержит соединение текущей транзакции вThreadLocal, поэтому все репозитории внутри@Transactionalработают в одном соединении. Обратная сторона: код, ушедший в другой поток черезCompletableFutureили@Async, транзакцию не видит
Правильное использование одно: set парой с remove в finally
REQUEST_ID.set(id);
try {
handle(request);
} finally {
REQUEST_ID.remove(); // иначе следующая задача на этом потоке увидит чужой id
}InheritableThreadLocal копирует значение родителя в дочерний поток в момент его создания. В обычном ThreadLocal у дочернего потока будет null. С пулами это почти бесполезно: поток создаётся один раз, а задачи приходят от разных запросов, и наследуется значение того, кто создал поток первым
С виртуальными потоками ThreadLocal работает, но миллион потоков — это миллион копий, поэтому для передачи контекста в Java 25 финализировали Scoped Values. Подробнее — на странице про виртуальные потоки
⚠️ Где ошибаются
- Ставят
lock()внутриtryили забываютfinally. Исключение в критической секции оставляет блокировку взятой навсегда, следующий поток виснет без единой строки в логе - Включают честную блокировку «для порядка». Пропускная способность падает в разы, а голодания, от которого она лечит, в задаче не было
- Ставят
ReentrantReadWriteLockна короткое чтение. Счётчик читателей становится точкой конкуренции, и выходит медленнее обычной блокировки - Меняют
synchronizedнаReentrantLockради виртуальных потоков. Это был совет для JDK 21–23, в JDK 24 пиннинг наsynchronizedубрали (JEP 491) - Делают проверку и действие двумя вызовами атомика.
if (a.get() < limit) a.incrementAndGet()— гонка, два потока пройдут проверку вместе. Проверку и запись делают одним CAS:a.updateAndGet(x -> x < limit ? x + 1 : x)
🎯 Вопросы с собеседований
Чем ReentrantLock отличается от synchronized?
Оба реентерабельные и дают одинаковые гарантии видимости. ReentrantLock умеет ждать с таймаутом через tryLock, прерываться в очереди через lockInterruptibly, держать несколько Condition и работать в честном режиме. Платят за это ручным unlock() в finally: забыл — блокировка висит навсегда. synchronized короче и снимается сам, поэтому его берут по умолчанию, а ReentrantLock — когда нужна конкретная возможность
Что такое атомики и CAS?
CAS — инструкция процессора: записать новое значение, только если в ячейке всё ещё ожидаемое. Атомики вроде AtomicInteger строят на ней цикл: прочитать, посчитать, попробовать compareAndSet, при неудаче повторить. Блокировок нет, поток не засыпает, и система не встанет, если какой-то поток вытеснили. Минусы: под сильной конкуренцией потоки крутятся вхолостую, обновить два поля атомарно нельзя, и есть проблема ABA, которую решает AtomicStampedReference с номером версии
Когда LongAdder лучше AtomicLong?
Когда много потоков часто пишут, а читают сумму редко: счётчики запросов, метрики. LongAdder раскладывает прибавления по ячейкам, у каждого потока своя, и CAS почти не конфликтуют, а sum() складывает их при чтении. В замере на 8 потоках он был быстрее больше чем на порядок, в одном потоке разницы нет. Для генерации уникальных номеров он не годится: sum() не атомарный снимок, а метода, который вернул бы новое значение, нет
Как устроен ThreadLocal и как через него получают утечку?
Значения лежат не в ThreadLocal, а в ThreadLocalMap внутри каждого Thread. Ключ в ней слабая ссылка на ThreadLocal, значение — сильная. Поток в пуле живёт вечно, поэтому значение живёт вместе с ним, даже когда сам ThreadLocal уже собран. Отсюда утечка памяти и чужие данные в следующей задаче на том же потоке. Лечится одним правилом: set парой с remove() в finally
📚 Что почитать
- Javadoc ReentrantLock — шаблон
lock/finally, что значит честность и почемуtryLock()её игнорирует - Javadoc StampedLock — пример с оптимистичным чтением и предупреждение о реентерабельности
- Пакет java.util.concurrent.atomic — все атомики и что они гарантируют про память
- Javadoc LongAdder — когда он лучше
AtomicLongи чем за это платят