Что такое Volatile

Question

Что такое Volatile

Тип вопроса: Многопоточность Вероятность: 42% Категория: Android Разработчик

Ответ

volatile в Java (и Kotlin) — это модификатор переменной, который гарантирует, что её значение всегда будет читаться из основной памяти, а не из кеша потока. Это обеспечивает видимость изменений переменной для всех потоков.

Когда использовать:

Когда переменная может изменяться разными потоками, и вам нужна гарантия, что каждый поток увидит актуальное значение.
Часто применяется для флагов или простых состояний, где атомарность операций не критична (для сложных сценариев лучше использовать Atomic классы или синхронизацию).

Пример:

@Volatile
var isRunning = false

fun start() {
    Thread {
        while (isRunning) { // Чтение из основной памяти
            // Работа в потоке
        }
    }.start()
}

⚠️ volatile не делает операции атомарными! Например, count++ всё равно потребует синхронизации.

Ответ 18+ 🔞

А, ну вот, про volatile спросили. Слушай, история-то древняя, как мир, но до сих пор мозги выносит новичкам. Ёпта, сейчас разжуем.

Представь себе, что у тебя есть переменная, ну, скажем, флаг isRunning. Один поток её выставляет, другой — читает. И вроде бы всё просто, ан нет! Современные процессоры — хитрая жопа. Они могут закешировать эту переменную у себя в ядре, и второй поток будет до скончания веков читать старое, закешированное значение, даже если первый уже сто раз его поменял. Получается пиздопроебищная ситуация: один кричит "стоп!", а другой глухой и дальше пашет.

Вот тут на сцену выходит наш герой — модификатор volatile. Это как будто ты на переменную повесил огромную табличку: "НЕ КЕШИРОВАТЬ, БЛЯДЬ!". Когда поток пишет в volatile-переменную, значение летит прямиком в основную память. А когда читает — херак! — идёт за ним тоже в основную память, игнорируя все свои локальные кеши. Видимость изменений на 100%, волнение ебать как успокаивает.

Когда это впендюрить нужно:

Самый классический случай — флаги завершения. Как в примере ниже. Один поток выставляет isRunning = false, и ты хочешь быть на 146% уверен, что рабочий поток это увидит и прекратит свои пляски. Иначе будет висеть вечно, ядрёна вошь.
Для каких-нибудь простых состояний, где операция чтения/записи сама по себе атомарна (например, присвоение boolean или int). Если логика сложнее — тут уже volatile не катит.

Смотри, как просто выглядит в Kotlin:

@Volatile // Вот эта аннотация — наш волшебный пинок под жопу
var isRunning = false

fun start() {
    Thread {
        while (isRunning) { // Каждое чтение — свежее, с пылу с жару, из основной памяти
            // делаем что-то полезное
        }
    }.start()
}

⚠️ И вот тут главная засада, из-за которой все обжигаются. Запомни раз и навсегда: volatile НЕ ДЕЛАЕТ ОПЕРАЦИИ АТОМАРНЫМИ. Он гарантирует только видимость, а не неделимость.

Что это значит на практике? Всё просто. Операция count++ — это же не один акт. Это "прочитать значение", "прибавить единицу", "записать значение". Два потока могут прочитать одно и то же старое значение, оба его увеличат и запишут. В итоге увеличение произойдёт всего один раз, а не два. Это называется "состояние гонки" (race condition), и volatile от него не спасает. Для таких штук нужны либо synchronized блоки, либо атомики из java.util.concurrent.atomic — AtomicInteger, к примеру.

Короче, резюмирую: volatile — это про видимость изменений между потоками. Всё. Не надо делать из него серебряную пулю для всех проблем многопоточности. Для простых флагов — идеально. Для счётчиков — хуй с горы, бесполезно.