Какие проблемы могут возникнуть при работе с 64-битными примитивами (double/long) в многопоточности?

Проблемы 64-битных примитивов в многопоточной среде

• Контекст: многопоточность и работа с примитивными типами
• На 32-битных системах чтение и запись 64-битных long и double могут выполняться неатомарно
• При отсутствии синхронизации такие операции способны быть прерваны, из-за чего записывается только часть значения
• Результатом становятся повреждённые значения и гонки данных
• Чтобы обеспечить атомарность, в Java используют volatile либо применяют синхронизацию
• Современные 64-битные CPU, как правило, поддерживают атомарность, однако результат зависит от платформы и JVM
• На практике для безопасного изменения 64-битных примитивов используют AtomicLong, синхронизированные методы или Lock

Итог: без корректных механизмов синхронизации при работе с 64-битными примитивами в многопоточном коде существует гарантированный риск гонок и некорректных данных.

Подробный ответ

Основной ответ

В многопоточном приложении операции с 64-битными примитивами, включая double и long, могут быть небезопасными из-за неатомарного чтения и записи на 32-битных платформах либо при отсутствии специальных гарантий со стороны языка и платформы. В результате появляются частично записанные или «разорванные» значения (torn reads/writes): один поток может получить значение, которое другой поток ещё не успел полностью обновить.

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

• На 32-битных архитектурах операции с 64-битными примитивами нередко неатомарны: присваивание и чтение выполняются в два этапа по 32 бита.
• В Java (до версии 5) атомарность гарантировалась только для доступа к переменным типов long и double, объявленным с модификатором volatile. При отсутствии volatile возможны torn reads.
• Чтобы устранить подобные проблемы, используют синхронизацию (synchronized), атомарные классы из java.util.concurrent.atomic — например, AtomicLong — либо volatile-переменные.
• Платформа x86-64 обычно поддерживает атомарность 64-битных операций, однако язык этого не гарантирует, а фактическое поведение может зависеть от используемых компилятора и JVM.

Практический контекст

В прикладных системах, например при подсчёте счётчиков или работе таймеров, некорректная реализация операций с 64-битными примитивами способна вызвать subtle баги: ошибки синхронизации и трудно обнаруживаемые race conditions. Поэтому для безопасного обмена 64-битными значениями между потоками применяют специализированные атомарные структуры (AtomicLong), volatile-поля или защищают доступ с помощью synchronized.