Что такое Just-In-Time Compiler?

Just-In-Time Compiler (JIT) в Java

Что это такое

Just-In-Time (JIT) Compiler — это компонент Java Virtual Machine (JVM), который компилирует байтокод в машинный код во время выполнения программы. Это позволяет Java коду работать почти так же быстро, как нативный скомпилированный код (C++, Rust), несмотря на то, что Java является интерпретируемым языком.

Архитектура Java выполнения

Java Source Code (.java)
       ↓
   Javac Compiler
       ↓
Bytecode (.class)
       ↓
JVM (Java Virtual Machine)
   ↓       ↓
Interpreter  JIT Compiler
   ↓       ↓
Machine Code (CPU Instructions)
       ↓
CPU Execution

Как работает JIT

Этап 1: Интерпретация

Первоначально JVM интерпретирует байтокод:

public class Counter {
    public static void main(String[] args) {
        int count = 0;
        // Эта строка выполняется интерпретатором
        for (int i = 0; i < 1000000; i++) {
            count++;  // Очень медленно в начале
        }
    }
}

// Интерпретация КАЖДОЙ операции:
// 1. Прочитать bytecode
// 2. Декодировать операцию
// 3. Найти обработчик
// 4. Выполнить

Этап 2: Мониторинг (Profiling)

JIT отслеживает какой код выполняется часто:

Операция        Количество выполнений
___________________________________________
count++              10,000
increment()          50,000  ← Hot Method!
findUser()          100,000  ← Hot Method!

Методы, которые выполняются часто, считаются "hot code" (горячий код).

Этап 3: Компиляция

Входит в работу JIT Compiler и компилирует горячий код:

// Вот этот метод выполняется 50,000 раз
public static int increment(int x) {
    return x + 1;
}

// JIT компилирует его в машинный код (примерно):
// mov eax, [esp + 4]      ; Загрузить аргумент
// add eax, 1              ; Прибавить 1
// ret                     ; Вернуть результат

Этап 4: Оптимизация

JIT выполняет различные оптимизации:

• Inlining — подставить код метода вместо вызова
• Dead code elimination — убрать неиспользуемый код
• Loop unrolling — развернуть цикл
• Escape analysis — оптимизировать объекты

// Исходный код
public void process(int n) {
    for (int i = 0; i < n; i++) {
        System.out.println(increment(i));
    }
}

// После JIT optimizations:
// Inlining: вызов increment() заменён на добавление 1
// Dead code elimination: if условия упрощены
// Loop unrolling: несколько итераций объединены

Два компилятора в JVM

C1 Compiler (Tier 1)

Быстрая компиляция с меньшей оптимизацией:

// Флаг для включения
// java -client MyClass

public class JitExample {
    private static int counter = 0;
    
    public static void main(String[] args) {
        // Этот метод быстро скомпилируется C1
        for (int i = 0; i < 100000; i++) {
            counter++;
        }
    }
}

C2 Compiler (Tier 2)

Медленная компиляция с агрессивной оптимизацией:

// Флаг для включения
// java -server MyClass

public class HotMethod {
    
    // Этот метод после многих вызовов
    // скомпилируется C2 с полной оптимизацией
    public static long fibonacci(int n) {
        if (n <= 1) return n;
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
    
    public static void main(String[] args) {
        // Вызываем много раз, чтобы попал в JIT
        for (int i = 0; i < 100000; i++) {
            fibonacci(20);
        }
    }
}

Пороги JIT компиляции

JIT начинает компилировать когда счётчик вызовов превышает порог:

# Просмотреть пороги
java -XX:+PrintCompilation -XX:+PrintInlining MyClass

# Вывод:
# 45  MyClass::increment (2 bytes)
# 46  MyClass::process (8 bytes) inline (hot)
# 47  java/lang/Integer::valueOf (26 bytes)

Демонстрация JIT эффекта

public class JitPerformance {
    
    public static void main(String[] args) {
        long sum = 0;
        
        // Поначалу медленно (интерпретация)
        long start = System.nanoTime();
        
        for (int iteration = 0; iteration < 5; iteration++) {
            sum = 0;
            
            for (int i = 0; i < 100000000; i++) {
                sum += add(i, 1);
            }
            
            long elapsed = System.nanoTime() - start;
            System.out.printf("Iteration %d: %d ns\n", 
                iteration, elapsed);
        }
    }
    
    // Будет скомпилирована после нескольких вызовов
    public static long add(long a, long b) {
        return a + b;
    }
}

// Вывод:
// Iteration 0: 450000000 ns  ← Интерпретация
// Iteration 1: 100000000 ns  ← Тепло
// Iteration 2:  50000000 ns  ← JIT начинает
// Iteration 3:  20000000 ns  ← JIT оптимизирует
// Iteration 4:  18000000 ns  ← Полная оптимизация

Включение вывода JIT информации

# Показать все операции JIT
java -XX:+PrintCompilation MyClass

# Показать детали компиляции
java -XX:+PrintCompilationDetails MyClass

# Показать inlining решения
java -XX:+PrintInlining MyClass

# Сохранить в файл
java -XX:+PrintCompilation -XX:PrintCompilationFile=jit.log MyClass

Deoptimization

Если JIT сделал неправильное предположение, код может быть деоптимизирован:

public class Deoptimization {
    
    static class Animal {
        public void sound() { System.out.println("Generic"); }
    }
    
    static class Dog extends Animal {
        @Override
        public void sound() { System.out.println("Woof"); }
    }
    
    static class Cat extends Animal {
        @Override
        public void sound() { System.out.println("Meow"); }
    }
    
    public static void main(String[] args) {
        Animal animal = new Dog();  // JIT оптимизирует как Dog
        
        for (int i = 0; i < 100000; i++) {
            animal.sound();  // JIT закэширует как Dog.sound()
        }
        
        // Потом передаём Cat
        animal = new Cat();
        animal.sound();  // DEOPTIMIZATION! Нужна переоптимизация
    }
}

Контроль JIT

# Отключить JIT (только интерпретация)
java -XX:+TieredCompilation=false -XX:TieredStopAtLevel=0 MyClass

# Изменить пороги
java -XX:CompileThreshold=1000 MyClass

# Изменить уровень оптимизации
java -XX:TieredStopAtLevel=3 MyClass  # 0=интерпретация, 4=max

# Использовать только C2
java -XX:-TieredCompilation -XX:+TieredCompilation MyClass

GraalVM и AOT компиляция

Модерные альтернативы JIT:

// GraalVM Native Image - Ahead-Of-Time компиляция
// Компилируется ПРИ СБОРКЕ, не во время выполнения

public class GraalVMExample {
    public static void main(String[] args) {
        System.out.println("Я скомпилирована в собственный код!");
    }
}

// Сборка:
// native-image GraalVMExample
// Результат: быстрый старт, меньше памяти

Сравнение подходов

Заключение

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