Why are Java 8 lambdas invoked using invokedynamic?

by

Lambdas are not invoked using invokedynamic, their object representation is created using invokedynamic, the actual invocation is a regular invokevirtual or invokeinterface.

For example:

// creates an instance of (a subclass of) Consumer 
// with invokedynamic to java.lang.invoke.LambdaMetafactory 
something(x -> System.out.println(x));   

void something(Consumer<String> consumer) {
      // invokeinterface
      consumer.accept("hello"); 
}

Any lambda has to become an instance of some base class or interface. That instance will sometimes contain a copy of the variables captured from the original method and sometimes a pointer to the parent object.
This can be implemented as an anonymous class.

Why invokedynamic

The short answer is: to generate code in runtime.

The Java maintainers chose to generate the implementation class in runtime.
This is done by calling java.lang.invoke.LambdaMetafactory.metafactory.
Since the arguments for that call (return type, interface, and captured parameters) can change, this requires invokedynamic.

Using invokedynamic to construct the anonymous class in runtime, allows the JVM to generate that class bytecode in runtime. The subsequent calls to the same statement use a cached version. The other reason to use invokedynamic is to be able to change the implementation strategy in the future without having to change already compiled code.

The road not taken

The other option would be the compiler creating an innerclass for each lambda instantiation, equivalent to translating the above code into:

something(new Consumer() { 
    public void accept(x) {
       // call to a generated method in the base class
       ImplementingClass.this.lambda$1(x);

       // or repeating the code (awful as it would require generating accesors):
       System.out.println(x);
    }
);

This requires creating classes in compile time and having to load then during runtime. The way jvm works those classes would reside in the same directory as the original class. And the first time you execute the statement that uses that lambda, that anonymous class would have to be loaded and initialized.

About performance

The first call to invokedynamic will trigger the anonymous class generation. Then the opcode invokedynamic is replaced with code that’s equivalent in performance to the writing manually the anonymous instantiation.

More Related Contents:

  1. In Java Lambda’s why is getClass() called on a captured variable
  2. Difference between final and effectively final
  3. Java 8 Lambda function that throws exception?
  4. How can I throw CHECKED exceptions from inside Java 8 streams?
  5. Java 8 lambdas, Function.identity() or t->t
  6. Very confused by Java 8 Comparator type inference
  7. Lambda Expression and generic defined only in method
  8. Reflection type inference on Java 8 Lambdas
  9. java.lang.NullPointerException is thrown using a method-reference but not a lambda expression
  10. Lambda expression to convert array/List of String to array/List of Integers
  11. Retrieving a List from a java.util.stream.Stream in Java 8
  12. Java “lambda expressions not supported at this language level”
  13. Java8: ambiguity with lambdas and overloaded methods
  14. Java 8, Streams to find the duplicate elements
  15. How do I use the new computeIfAbsent function?
  16. Java8 Lambdas and Exceptions
  17. Why can method reference use non-final variables?
  18. How to make a lambda expression define toString in Java 8?
  19. Java 8 grouping using custom collector?
  20. How can I throw CHECKED exceptions from inside Java 8 lambdas/streams?
  21. How to apply multiple predicates to a java.util.Stream?
  22. Parallel stream from a HashSet doesn’t run in parallel
  23. What is a stack map frame
  24. How to emit and execute Java bytecode at runtime?
  25. Understanding metaspace line in JVM heap printout
  26. Non-interference exact meaning in Java 8 streams
  27. Purpose of third argument to ‘reduce’ function in Java 8 functional programming
  28. Are Java 8 lambdas compiled as inner classes, methods or something else? [duplicate]
  29. Java 8 lambda for selecting top salary employee for each department
  30. Difference between method reference Bound Receiver and Unbound Receiver

Leave a Comment