Что такое инструкция invoke dynamic?

Инструкция INVOKEDYNAMIC

INVOKEDYNAMIC — это байт-код инструкция Java Virtual Machine (JVM), введённая в Java 7, которая позволяет динамически связывать методы во время выполнения. Это одна из четырёх инструкций вызова методов в JVM и самая мощная.

Четыре способа вызова методов в JVM

// 1. INVOKESTATIC — вызов статического метода
Math.sqrt(16.0); // Байт-код: invokestatic

// 2. INVOKESPECIAL — вызов приватного метода или конструктора
super.toString();  // Байт-код: invokespecial

// 3. INVOKEVIRTUAL — вызов метода экземпляра (виртуальный вызов)
object.toString();  // Байт-код: invokevirtual

// 4. INVOKEDYNAMIC — динамическое связывание (Java 7+)
// Используется для lambda выражений, method references и других конструкций
() -> System.out.println("Hello"); // Байт-код: invokedynamic

Почему нужна INVOKEDYNAMIC?

Основная проблема: Java изначально была языком, где все методы связываются либо статически, либо через виртуальную диспетчеризацию. Это неудобно для:

• Lambda выражений (Java 8)
• Динамических языков на JVM (Groovy, JRuby)
• Функционального программирования
• Специальных dispatch стратегий

Инвентарь INVOKEDYNAMIC позволяет переложить решение о том, какой метод вызвать, на сам язык программирования.

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

Уникальность INVOKEDYNAMIC в том, что она не связывает метод статически. Вместо этого она вызывает bootstrap метод (специальный метод), который решает, какой метод на самом деле нужно вызвать.

// Пример с lambda (внутри используется INVOKEDYNAMIC)
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

numbers.forEach(n -> System.out.println(n * 2));

// Байт-код:
// invokedynamic #28, 0  // (Ljava/lang/Integer;)V
//   Bootstrap: java.lang.invoke.LambdaMetafactory.metafactory
//   Type arguments: (Ljava/lang/Integer;)V
//   MethodHandle: System.out.println(Ljava/lang/Integer;)V

Компоненты INVOKEDYNAMIC

1. Bootstrap Method — метод, который вызывается при первом вызове INVOKEDYNAMIC:

public static CallSite bootstrap(
    MethodHandles.Lookup lookup,    // Доступ к private членам
    String name,                     // Имя метода
    MethodType type,                 // Сигнатура метода
    Object... args                   // Дополнительные аргументы
) throws Throwable {
    // Возвращает CallSite с целевым методом
}

2. Call Site — представляет связь между вызывающим кодом и целевым методом:

// CallSite содержит MethodHandle целевого метода
CallSite site = ...
MethodHandle target = site.getTarget();
// Будущие вызовы будут использовать этот MethodHandle

3. Method Handle — низкоуровневая ссылка на метод:

MethodHandles.Lookup lookup = MethodHandles.lookup();

// Получить MethodHandle на публичный метод
MethodHandle mh = lookup.findVirtual(
    String.class,           // Класс
    "length",             // Имя метода
    MethodType.methodType(int.class) // Сигнатура
);

// Вызвать через MethodHandle
int length = (int) mh.invoke("hello"); // 5

Практический пример: Lambda выражение

Когда компилятор видит lambda:

Function<Integer, Integer> square = x -> x * x;

Он генерирует:

// Bootstrap метод (вызывается один раз)
public static CallSite bootstrap(
    MethodHandles.Lookup lookup,
    String name,
    MethodType type) throws Throwable {
    
    // Создаёт MethodHandle на синтетический метод
    MethodHandle target = ...
    
    // Возвращает CallSite
    return new ConstantCallSite(target);
}

// Использование
invokedynamic apply(int) // Вызовет bootstrap, затем целевой метод

Преимущества INVOKEDYNAMIC

1. Гибкость:

// Можно реализовать свою стратегию диспетчеризации
// Например, multiple dispatch (как в Julia или Lisp)

2. Производительность:

// JVM может оптимизировать на основе runtime информации
// Call Site Caching — результат bootstrap кэшируется

3. Поддержка динамических языков:

// Groovy, JRuby и другие языки используют INVOKEDYNAMIC
// для реализации динамической типизации

4. Lambda выражения:

// Компилятор может использовать разные стратегии
// для реализации lambda (анонимный класс, генерация метода и т.д.)
// без изменения байт-кода приложения

MethodHandle vs Reflection

// Reflection (старый подход)
Method method = String.class.getMethod("length");
int length = (int) method.invoke("hello"); // медленнее

// MethodHandle (новый подход с INVOKEDYNAMIC)
MethodHandle mh = MethodHandles.lookup()
    .findVirtual(String.class, "length", 
                 MethodType.methodType(int.class));
int length = (int) mh.invoke("hello"); // быстрее

MethodHandle работает быстрее благодаря кэшированию и JIT оптимизациям.

Пример с Custom Call Site

// Позволяет реализовать сложную логику диспетчеризации
public class PolymorphicCallSite extends MutableCallSite {
    public PolymorphicCallSite(MethodType type) {
        super(type);
        setTarget(this::dispatch);
    }
    
    private Object dispatch(Object... args) throws Throwable {
        // Определить тип аргумента и выбрать нужный метод
        Class<?> argType = args[0].getClass();
        
        MethodHandle target = getTargetForType(argType);
        setTarget(target); // Обновить target для следующего вызова
        
        return target.invokeWithArguments(args);
    }
}

Когда встречается INVOKEDYNAMIC

• Lambda выражения — основное использование
• Method References — System.out::println
• Динамические языки на JVM
• String concatenation (Java 9+) — в некоторых случаях
• Записи (Records) — некоторые части

Отладка INVOKEDYNAMIC

# Просмотр байт-кода с INVOKEDYNAMIC
javap -c -v MyClass.class

# Вывод:
# invokedynamic #28, 0  // Method java.lang.invoke.LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;...)

ИНВОКЕДИНАМИК — сложный, но мощный механизм, который позволяет Java реализовать современные языковые конструкции эффективно.