Understanding Java's invokedynamic and Lambda Implementation

Although the latest JDK versions are beyond 20, JDK 8 still dominates daily development due to its compatibility, stability, and useful language features—most notably Lambda expressions.

This article explores Lambda expressions from both the Java language and JVM perspectives.

Java and the JVM : The JVM is a high‑level virtual machine that executes bytecode. Java code is compiled into bytecode that the JVM runs. While Java runs on the JVM, the JVM can also host other languages that compile to its bytecode.

invokedynamic : Introduced in Java 7, the invokedynamic instruction allows the application code to decide method resolution at runtime, unlike the four traditional invoke* instructions that require the target method to be fixed at compile time. This enables a two‑stage call: first a bootstrap method (BSM) is invoked to produce a CallSite , then the CallSite provides a MethodHandle that is finally invoked.

The bootstrap method used by Lambda expressions is java.lang.invoke.LambdaMetafactory#metafactory . It receives the functional interface type (e.g., IntUnaryOperator ), a static method reference that contains the Lambda body, and additional metadata, then generates a synthetic class that implements the functional interface.

MethodHandle : Since Java methods are not first‑class citizens, the JDK provides MethodHandle as a typed, high‑performance alternative to reflection. The generated synthetic class holds a MethodHandle pointing to the bootstrap‑produced implementation.

Lambda compilation : Each Lambda is compiled into a private static method (e.g., lambda$main$0 ). The compiler then creates a CallSite that links this method to the functional interface via LambdaMetafactory . For stateless Lambdas the generated class is cached (via ConstantCallSite ) and reused; for stateful Lambdas that capture variables, a new instance is created on each call, similar to an anonymous inner class.

Performance : Stateless Lambdas have negligible overhead after the first invocation. Lambdas that capture variables incur the same allocation cost as anonymous inner classes.

Final variables : Captured local variables must be effectively final; this restriction is a language design choice to avoid subtle bugs.

The article also provides sample bytecode, synthetic class listings, and references for further reading.