IllegalMonitorStateException в Java: как JIT-деоптимизация ломает неблокирующий API

IllegalMonitorStateException возникает, когда поток вызывает wait() или notify() на объекте, чей монитор ему не принадлежит. Обычно это указывает на ошибку синхронизации, но бывают случаи, когда код написан безупречно, а исключение всё равно появляется. В этой статье мы разберём реальный кейс, где неблокирующий API на CompletableFuture неожиданно блокировался из-за деоптимизации JIT-компилятора. Вы узнаете, как это происходит, как диагностировать проблему и какие меры помогут её избежать.

Как JIT-деоптимизация приводит к потере монитора

В нормальном режиме приложение на CompletableFuture работает без блокировок. Однако под нагрузкой возникают таймауты и IllegalMonitorStateException. Корень проблемы — в деоптимизации JIT-компилятора. JIT-компилятор Java HotSpot VM может оптимизировать код, убирая избыточные проверки синхронизации, если уверен, что монитор уже захвачен. Если происходит деоптимизация (например, из-за загрузки нового класса или изменения профиля выполнения), скомпилированный код откатывается к интерпретируемому. В этот момент может потеряться информация о том, что монитор уже удерживается. Поток вызывает wait() или notify() без владения монитором, и выбрасывается IllegalMonitorStateException.

Важно понимать, что это не баг JVM, а редкий сценарий, связанный с тем, как JIT-компилятор оптимизирует код с синхронизацией. Проблема проявляется только при специфической нагрузке, когда профилирование выполнения заставляет компилятор принять неверное решение об оптимизации.

Предыстория и контекст

IllegalMonitorStateException — хорошо известное исключение, но обычно оно возникает из-за ошибок программиста: например, если забыть синхронизировать блок перед вызовом wait(). В данном случае код был написан правильно, с использованием синхронизированных блоков. Проблема оказалась глубже — на уровне JIT-компиляции.

Это не первый случай, когда оптимизации JIT приносят сюрпризы. Например, известны проблемы с «замёрзшими» циклами, когда компилятор выкидывает проверки, которые кажутся ему избыточными. Аналогично здесь: компилятор решил, что монитор гарантированно захвачен, и убрал проверку, но после деоптимизации эта гарантия исчезла.

Как работает деоптимизация JIT в Java?

Когда поток входит в синхронизированный блок, JIT-компилятор может встроить код захвата монитора. Если компилятор уверен, что монитор уже захвачен (например, на основе профилирования), он может пропустить повторный захват. При деоптимизации скомпилированный код заменяется на интерпретируемый, который не знает о предыдущем захвате. В результате интерпретатор пытается захватить монитор заново, но не может, так как он уже захвачен тем же потоком? На самом деле, монитор в Java реентерабельный, поэтому повторный захват тем же потоком разрешён. Проблема в том, что после деоптимизации код может оказаться вне синхронизированного блока с точки зрения интерпретатора, но при этом пытаться вызвать wait() или notify(). То есть поток теряет контекст владения монитором.

Технические подробности расследования

Автор использовал флаг -XX:+PrintCompilation для отслеживания компиляций и деоптимизаций. Также применялись ThreadMXBean для анализа состояния потоков и дампы потоков в момент ошибки. Выяснилось, что проблема воспроизводилась только при определённой нагрузке, когда JIT решал деоптимизировать метод, содержащий синхронизированный блок.

Решение оказалось неожиданным: добавление try-catch вокруг подозрительного участка кода. Это заставило JIT-компилятор отказаться от некоторых оптимизаций, так как блок try-catch создаёт дополнительные точки исключений. В результате деоптимизация перестала приводить к потере монитора. Также помогло явное указание синхронизации через synchronized (this) вместо использования вспомогательных методов, которые могли быть проигнорированы компилятором.

Кого затронет и как избежать

Проблема актуальна для разработчиков, использующих неблокирующие API на CompletableFuture или собственные реализации с синхронизацией. Особенно это касается высоконагруженных систем, где JIT-компилятор активно оптимизирует код. В российских компаниях, где Java остаётся одним из основных языков для бэкенда, такие случаи могут приводить к трудноуловимым багам в production.

Разработчикам стоит обратить внимание на подобные сценарии: если в логах появляется IllegalMonitorStateException при, казалось бы, правильном коде, стоит проверить, не связана ли проблема с деоптимизацией. Инструменты вроде -XX:+PrintCompilation и JFR (Java Flight Recorder) могут помочь в диагностике. Рекомендуется тестировать критические участки кода с синхронизацией под нагрузкой и с включённым логированием компиляции.

Что будет дальше

С выходом новых версий JDK (например, Project Loom и виртуальные потоки) синхронизация в Java претерпевает изменения. В частности, виртуальные потоки используют другие механизмы блокировки, которые могут быть менее подвержены подобным проблемам. Однако пока большинство production-систем работают на классических потоках, этот кейс остаётся актуальным.

Автор предполагает, что проблема может быть воспроизведена и на других версиях JVM, в том числе от других вендоров. Поэтому важно быть готовым к неожиданным взаимодействиям между оптимизациями и синхронизацией.

Итог

IllegalMonitorStateException, вызванный деоптимизацией JIT — редкий, но поучительный случай. Он напоминает, что даже в зрелых языках и платформах могут быть неочевидные взаимодействия между оптимизациями и синхронизацией. Добавление try-catch или перестройка кода могут стать не просто защитой от исключений, а способом управления поведением JIT-компилятора. Следите за логами, используйте профилировщики и не забывайте: иногда блок catch важнее коллбэка.