Главная › Блог › Java › Многопоточность в Java: вопросы на собеседовании и короткие ответы

Многопоточность в Java: вопросы на собеседовании и короткие ответы

Зачем вообще спрашивают многопоточность

Многопоточность — тема, где легко заучить термины и провалиться на первом же уточняющем вопросе. Интервьюера интересует не определение Thread, а понимание механики: почему гонка данных не всегда воспроизводится, почему synchronized не панацея и чем поток отличается от задачи, которую он выполняет. Разберём основные блоки темы и вопросы, которые вокруг них крутятся.

Поток, race condition и видимость

Платформенный поток в Java (класс java.lang.Thread, Java SE 21) имеет собственный стек, но делит общую кучу с другими потоками процесса. Отсюда два разных класса проблем:

  • Race condition — несколько потоков одновременно меняют общее состояние, и результат зависит от порядка выполнения.
  • Видимость изменений — поток может не увидеть актуальное значение переменной, изменённое другим потоком. Согласно модели памяти Java (JLS, глава 17), переупорядочивать код может JIT-компилятор, процессор или память — спецификация в совокупности называет всё это «компилятором» в контексте переупорядочивания.

Это разные проблемы, и решают их разными инструментами: атомарность — через synchronized/Lock/атомики, видимость — через volatile или те же блокировки (при корректной синхронизации они обеспечивают оба эффекта).

Представь общий банковский счёт, которым пользуются два кассира без координации между собой. Оба читают баланс «1000», оба добавляют по 100 и записывают «1100» — хотя должно быть 1200. Это и есть race condition: операция «прочитать-изменить-записать» не атомарна.

Инструменты синхронизации

Классический набор: synchronized (монитор объекта), ReentrantLock (явная блокировка с поддержкой try-lock, прерываемого ожидания и опциональной политикой справедливости, Java SE 21), ReadWriteLock (отдельные блокировки для чтения и записи, читатели могут работать параллельно, пока нет писателя), атомарные классы (AtomicInteger, AtomicReference) на основе CAS-операций, и concurrent-коллекции вроде ConcurrentHashMap<K,V>, где операции чтения не блокируют и могут выполняться параллельно с обновлениями. На собеседовании важно не перечислить список, а объяснить, когда что выбирать:

  • Простой счётчик без сложной логики — атомарный класс, если нужна только атомарность одиночной операции.
  • Критическая секция с несколькими взаимосвязанными операциями — synchronized или ReentrantLock.
  • Нужен таймаут на захват блокировки (tryLock(long, TimeUnit)) или прерываемое ожидание (lockInterruptibly()) — для этого нужен ReentrantLock, у synchronized такого API нет.
  • Много чтений, мало записей — ReadWriteLock или неблокирующая структура вроде ConcurrentHashMap<K,V>.
class Counter {
    private final AtomicInteger value = new AtomicInteger();

    void increment() {
        value.incrementAndGet(); // атомарная операция на основе CAS
    }

    int get() {
        return value.get();
    }
}
Риск, о котором легко забыть: если критическая секция защищена не полностью — например, геттер синхронизирован, а сеттер нет, — гарантии видимости и атомарности для этого поля не выполняются. Синхронизация должна охватывать все операции чтения и записи общего состояния, иначе защита не работает.

Потоки vs задачи: Executor и пулы

Создание потока — заметно более дорогая операция, чем вызов метода. На практике вместо создания Thread напрямую чаще используют ExecutorService (java.util.concurrent, Java SE 21), который переиспользует потоки пула для выполнения множества задач. Важно различать поведение при ошибке: метод submit возвращает Future<T>, и если задача завершилась исключением, оно оборачивается и выбрасывается как ExecutionException только при вызове get(). Метод execute (унаследованный от Executor) такого оборачивания не делает — исключение из задачи не перехватывается через Future и распространяется как необработанное в потоке, который его выполнял.

Deadlock, livelock, starvation

Три разных сценария, которые путают на собесе:

  • Deadlock — потоки взаимно ждут ресурсы друг друга, циклическая зависимость, никто не продвигается.
  • Livelock — потоки активно работают, но реагируют друг на друга так, что состояние не меняется (как два человека в коридоре, уступающие дорогу синхронно в одну сторону).
  • Starvation — один поток постоянно обделяется ресурсом. Документация ReentrantLock (Java SE 21) отдельно отмечает: даже при справедливой политике блокировки (fair) один из потоков может захватывать её подряд несколько раз, пока другие активные потоки не продвигаются — то есть справедливость блокировки не гарантирует справедливости планирования потоков в целом.

Вопросы с собеседований

Чем race condition отличается от data race?
Согласно JLS (§17.4.5), data race — конкретная ситуация: в коде есть запись в переменную в одном потоке и чтение той же переменной в другом, и эти операции не упорядочены синхронизацией (хотя бы одна из конфликтующих операций — запись). Race condition — более широкое понятие: некорректный результат из-за недетерминированного порядка операций; он может возникать и при формальном наличии синхронизации, если бизнес-логика операции не атомарна в целом (например, последовательность «проверить-затем-изменить» защищена двумя разными блокировками).
Можно ли прервать поток, заблокированный на synchronized?
Нет. Поток, ожидающий захвата монитора в блоке synchronized, не реагирует на interrupt() — он продолжит ждать, пока монитор не освободится. Для прерываемого ожидания блокировки нужен ReentrantLock.lockInterruptibly().
Что произойдёт, если исключение вылетит внутри задачи, отправленной через submit в ExecutorService?
Согласно документации ExecutorService (Java SE 21), submit возвращает Future, через который можно отслеживать завершение задачи. Если задача завершилась исключением, оно оборачивается и повторно выбрасывается как ExecutionException только при вызове future.get(). Если вместо submit использовать execute() (метод интерфейса Executor), такого оборачивания не происходит.
Почему увеличение счётчика через i++ не потокобезопасно, даже если поле volatile?
volatile гарантирует видимость записанного значения другими потоками, но не делает атомарной составную операцию «прочитать-прибавить-записать». Между чтением и записью другой поток может успеть изменить значение. Для атомарного инкремента нужен AtomicInteger (метод incrementAndGet()) или синхронизация всей операции целиком.
Как на практике найти deadlock в работающем приложении?
Снять thread dump, например утилитой jstack. В дампе видно состояние каждого потока и то, какие блокировки/мониторы он удерживает и каких ожидает — по этой информации можно восстановить цикл взаимного ожидания. Дальше нужно привести порядок захвата блокировок к единому во всём коде, чтобы цикл не мог возникнуть.

На собеседовании полезно не просто выдать определение, а сразу привести мини-пример кода, где проблема воспроизводится, и показать, каким инструментом её закрыть. Это демонстрирует, что тема понята на уровне механики, а не выучена по карточкам.

Ещё разборы