Что хотят услышать интервьюеры:

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

Определение:

Условие гонки возникает, когда результат работы программы зависит от порядка выполнения потоков при одновременном доступе к общим данным. Чтобы этого избежать, нужно сделать операцию безопасной для многопоточности: либо исключить одновременную запись, либо использовать атомарные операции, либо убрать совместно изменяемое состояние.

На практике используют несколько подходов:

synchronized — защищает критическую секцию и гарантирует взаимное исключение.
Lock / ReentrantLock — более гибкая альтернатива синхронизации.
volatile — обеспечивает видимость изменений между потоками, но не делает составные операции атомарными.
Atomic* классы — атомарные операции без явной блокировки.
Thread-safe коллекции — например, специализированные конкурентные структуры.
Иммутабельность и thread confinement — если состояние не разделяется, гонок не возникает.

Пример использования:

Допустим, несколько потоков увеличивают общий счётчик. Без синхронизации значение может потеряться из-за одновременного чтения и записи.

import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
    private final AtomicInteger counter = new AtomicInteger(0);

    public void increment() {
        counter.incrementAndGet();
    }

    public int getValue() {
        return counter.get();
    }
}

Пояснение кода:

В этом примере используется AtomicInteger, чтобы инкремент был атомарным.

counter хранит общее значение, доступное из нескольких потоков.
Метод incrementAndGet() выполняет увеличение как неделимую операцию.
Если два потока вызовут increment() одновременно, одно обновление не потеряется.
Метод get() безопасно читает актуальное значение.

Если бы использовался обычный int и операция counter++, она состояла бы из нескольких шагов: чтение, увеличение, запись. Между ними другой поток мог бы вмешаться, и итоговое значение стало бы некорректным.

Ключевые моменты:

volatile решает проблему видимости, но не заменяет атомарность.
synchronized и Lock подходят, когда нужно защитить целую критическую секцию.
Atomic* классы хороши для простых операций над числами и ссылками.
Чем меньше разделяемого изменяемого состояния, тем проще избежать гонок.
Thread-safe коллекции и иммутабельные объекты часто уменьшают необходимость в ручной синхронизации.
Нельзя считать код безопасным только потому, что в нём есть volatile или sleep() — это не защита от race condition.

Какие способы существует для предотвращения условий гонки в многопоточных приложениях?