К содержимому
Войти

Java Road Map

⚛️ Lock, атомики и CAS

synchronized закрывает большую часть задач, но не умеет ждать блокировку с таймаутом, прерываться в очереди и держать несколько условий ожидания. Для этого в java.util.concurrent.locks есть ReentrantLock и его родня, а для счётчиков и флагов — атомики на CAS, которые обходятся без блокировок совсем. Интервьюеры обычно проверяют, чем ReentrantLock отличается от synchronized, как устроен CAS, когда брать LongAdder и почему ThreadLocal в пуле надо чистить

🔒 ReentrantLock

Чем отличается от synchronized

Оба взаимоисключающие и реентерабельные: поток, который уже держит блокировку, может взять её ещё раз, счётчик захватов растёт, и отпустить нужно столько же раз. Видимость изменений тоже одинаковая: unlock для следующего lock работает как выход из монитора для входа, правила видимости разобраны на странице про JMM, synchronized и volatile

synchronizedReentrantLock
ОсвобождениеСамо при выходе из блока, даже по исключениюВручную, unlock() в finally
Ждать с таймаутомНетtryLock(timeout, unit)
Прервать ожиданиеНет, поток в BLOCKED не реагирует на interruptlockInterruptibly()
Условия ожиданияОдно: 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 и чем за это платят