lambda表达式实现原理分析

2022年01月13日 阅读数:4
这篇文章主要向大家介绍lambda表达式实现原理分析,主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

本文将深刻了解lambda表达式的实现原理和这样的实现方案的取舍权衡。html

Java为何须要lambda表达式?

可以提高代码简洁性、提升代码可读性。java

例如,在平时的开发过程当中,把一个列表转换成另外一个列表或map等等这样的转换操做是一种常见需求。
在没有lambda以前一般都是这样实现的。git

List<Long> idList = Arrays.asList(1L, 2L, 3L);
List<Person> personList = new ArrayList<>();
for (long id : idList) {
    personList.add(getById(id));
}

代码重复多了以后,你们就会对这种常见代码进行抽象,造成一些类库便于复用。
上面的需求能够抽象成:对一个列表中的每一个元素调用一个转换函数转换并输出结果列表。github

interface Function {
    <T, R> R fun(T input);
}
<T, R> List<R> map(List<T> inputList, Function function) {
    List<R> mappedList = new ArrayList<>();
    for (T t : inputList) {
        mappedList.add(function.fun(t));
    }
    return mappedList;
}

有了这个抽象,最开始的代码即可以”简化”成编程

List<Long> idList = Arrays.asList(1L, 2L, 3L);
List<Person> personList = map(idList, new Function<Long, Person>() {
    @Override
    public Person fun(Long input) {
        return getById(input);
    }
});

虽然实现逻辑少了一些,可是一样也遗憾地发现,代码行数还变多了。
由于Java语言中函数并不能做为参数传递到方法中,函数只能寄存在一个类中表示。为了可以把函数做为参数传递到方法中,咱们被迫使用了匿名内部类实现,须要加至关多的冗余代码。
在一些支持函数式编程的语言(Functional Programming Language)中(例如Python, Scala, Kotlin等),函数是一等公民,函数能够成为参数传递以及做为返回值返回。
例如在Kotlin中,上述的代码能够缩减到很短,代码只包含关键内容,没有冗余信息。bootstrap

val personList = idList.map { id -> getById(id) }

这样的编写效率差距也致使了一部分Java用户流失到其余语言,不过最终终于在JDK8也提供了Lambda表达式能力,来支持这种函数传递。数组

List<Person> personList = map(idList, input -> getById(input));

Lambda表达式只是匿名内部类的语法糖吗?

若是要在Java语言中实现lambda表达式,初步观察,经过javac把这种箭头语法还原成匿名内部类,就能够轻松实现,由于它们功能基本是等价的(IDEA中常常有提示)。安全

可是匿名内部类有一些缺点。oracle

  1. 每一个匿名内部类都会在编译时建立一个对应的class,而且是有文件的,所以在运行时不可避免的会有加载、验证、准备、解析、初始化的类加载过程。
  2. 每次调用都会建立一个这个匿名内部类class的实例对象,不管是有状态的(capturing,从上下文中捕获一些变量)仍是无状态(non-capturing)的内部类。

invokedynamic介绍

若是有一种函数引用、指针就行了,但JVM中并无函数类型表示。
Java中有表示函数引用的对象吗,反射中有个Method对象,但它的问题是性能问题,每次执行都会进行安全检查,且参数都是Object类型,须要boxing等等。app

还有其余表示函数引用的方法吗?MethodHandle,它是在JDK7中与invokedynamic指令等一块儿提供的新特性。

但直接使用MethodHandle来实现,因为没有签名信息,会遇不能重载的问题。而且MethodHandle的invoke方法性能不必定能保证比字节码调用好。

invokedynamic出现的背景

JVM上的动态语言(JRuby, Scala等),要实现dynamic typing动态类型,是比较麻烦的。
这里简单解释一下什么是dynamic typing,与其相对的是static typing静态类型。
static typing: 全部变量的类型在编译时都是肯定的,而且会进行类型检查。
dynamic typing: 变量的类型在编译时不能肯定,只能在运行时才能肯定、检查。

例如以下动态语言的例子,a和b的类型都是未知的,所以a.append(b)这个方法是什么也是未知的。

def add(val a, val b)
    a.append(b)

而在Java中a和b的类型在编译时就能肯定。

SimpleString add(SimpleString a, SimpleString b) {
    return a.append(b);
}

编译后的字节码以下,经过invokevirtual明确调用变量a的函数签名为(LSimpleString;)LSimpleString;的方法。

0: aload_1
1: aload_2
2: invokevirtual #2 // Method SimpleString.append:(LSimpleString;)LSimpleString;
5: areturn

关于方法调用的字节码指令,JVM中提供了四种。
invokestatic - 调用静态方法
invokeinterface - 调用接口方法
invokevirtual - 调用实例非接口方法的public方法
invokespecial - 其余的方法调用,private,constructor, super
这几种方法调用指令,在编译的时候就已经明确指定了要调用什么样的方法,且均须要接收一个明确的常量池中的方法的符号引用,并进行类型检查,是不能随便传一个不知足类型要求的对象来调用的,即便传过来的类型中也刚好有同样的方法签名也不行。

invokedynamic功能

这个限制让JVM上的动态语言实现者感到很艰难,只能暂时经过性能较差的反射等方式实现动态类型。
这说明在字节码层面没法支持动态分派,该怎么办呢,又用到了你们熟悉的”All problems in computer science can be solved by another level of indirection”了。
要实现动态分派,既然不能在编译时决定,那么咱们把这个决策推迟到运行时再决定,由用户的自定义代码告诉给JVM要执行什么方法。

在jdk7,Java提供了invokedynamic指令来解决这个问题,同时搭配的还有java.lang.invoke包。
这个指令大部分用户不太熟悉,由于不像invokestatic等指令,它在Java语言中并无和它相关的直接概念。

关键的概念有以下几个

  1. invokedynamic指令: 运行时JVM第一次到这里的时候会进行linkage,会调用用户指定的bootstrap method来决定要执行什么方法,以后便不须要这个解析步骤。这个invokedynamic指令出现的地方也叫作dynamic call site
  2. Bootstrap Method: 用户能够本身编写的方法,实现本身的逻辑最终返回一个CallSite对象。
  3. CallSite: 负责经过getTarget()方法返回MethodHandle
  4. MethodHandle: MethodHandle表示的是要执行的方法的指针

再串联起来梳理下

invokedynamic在最开始时处于未连接(unlinked)状态,这时这个指令并不知道要调用的目标方法是什么。
当JVM要第一次执行某个地方的invokedynamic指令的时候,invokedynamic必须先进行连接(linkage)。
连接过程经过调用一个boostrap method,传入当前的调用相关信息,bootstrap method会返回一个CallSite,这个CallSite中包含了MethodHandle的引用,也就是CallSite的target。
invokedynamic指令便连接到这个CallSite上,并把全部的调用delegate到它当前的targetMethodHandle上。根据target是否须要变换,CallSite能够分为MutableCallSiteConstantCallSiteVolatileCallSite等,能够经过切换target MethodHandle实现动态修改要调用的方法。

invokedynamic

lambda表达式真正是如何实现的

下面直接看一下目前java实现lambda的方式

如下面的代码为例

public class RunnableTest {
    void run() {
        Function<Integer, Integer> function = input -> input + 1;
        function.apply(1);
    }
}

编译后经过javap查看生成的字节码

void run();
    descriptor: ()V
    flags:
    Code:
      stack=2, locals=2, args_size=1
         0: invokedynamic #2,  0              // InvokeDynamic #0:apply:()Ljava/util/function/Function;
         5: astore_1
         6: aload_1
         7: iconst_1
         8: invokestatic  #3                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
        11: invokeinterface #4,  2            // InterfaceMethod java/util/function/Function.apply:(Ljava/lang/Object;)Ljava/lang/Object;
        16: pop
        17: return
      LineNumberTable:
        line 12: 0
        line 13: 6
        line 14: 17
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      18     0  this   Lcom/github/liuzhengyang/invokedyanmic/RunnableTest;
            6      12     1 function   Ljava/util/function/Function;
      LocalVariableTypeTable:
        Start  Length  Slot  Name   Signature
            6      12     1 function   Ljava/util/function/Function<Ljava/lang/Integer;Ljava/lang/Integer;>;

private static java.lang.Integer lambda$run$0(java.lang.Integer);
    descriptor: (Ljava/lang/Integer;)Ljava/lang/Integer;
    flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: invokevirtual #5                  // Method java/lang/Integer.intValue:()I
         4: iconst_1
         5: iadd
         6: invokestatic  #3                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
         9: areturn
      LineNumberTable:
        line 12: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      10     0 input   Ljava/lang/Integer;

对应Function<Integer, Integer> function = input -> input + 1;这一行的字节码为

0: invokedynamic #2,  0              // InvokeDynamic #0:apply:()Ljava/util/function/Function;
5: astore_1

这里再复习一下invokedynamic的步骤。

  1. JVM第一次解析时,调用用户定义的bootstrap method
  2. bootstrap method会返回一个CallSite
  3. CallSite中可以获得MethodHandle,表示方法指针
  4. JVM以后调用这里就再也不须要从新解析,直接绑定到这个CallSite上,调用对应的target MethodHandle,并可以进行inline等调用优化

第一行invokedynamic后面有两个参数,第二个0没有意义固定为0 第一个参数是#2,指向的是常量池中类型为CONSTANT_InvokeDynamic_info的常量。

#2 = InvokeDynamic      #0:#32         // #0:apply:()Ljava/util/function/Function;

这个常量对应的#0:#32中第二个#32表示的是这个invokedynamic指令对应的动态方法的名字和方法签名(方法类型)

#32 = NameAndType        #43:#44        // apply:()Ljava/util/function/Function;

第一个#0表示的是bootstrap method在BootstrapMethods表中的索引。在javap结果的最后看到是

BootstrapMethods:
  0: #28 invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
    Method arguments:
      #29 (Ljava/lang/Object;)Ljava/lang/Object;
      #30 invokestatic com/github/liuzhengyang/invokedyanmic/RunnableTest.lambda$run$0:(Ljava/lang/Integer;)Ljava/lang/Integer;
      #31 (Ljava/lang/Integer;)Ljava/lang/Integer;

再看下BootstrapMethods属性对应JVM虚拟机规范里的说明。

BootstrapMethods_attribute {
    u2 attribute_name_index;
    u4 attribute_length;
    u2 num_bootstrap_methods;
    {   u2 bootstrap_method_ref;
        u2 num_bootstrap_arguments;
        u2 bootstrap_arguments[num_bootstrap_arguments];
    } bootstrap_methods[num_bootstrap_methods];
}

bootstrap_method_ref
The value of the bootstrap_method_ref item must be a valid index into the constant_pool table. The constant_pool entry at that index must be a CONSTANT_MethodHandle_info structure

bootstrap_arguments[]
Each entry in the bootstrap_arguments array must be a valid index into the constant_pool table. The constant_pool entry at that index must be a CONSTANT_String_info, CONSTANT_Class_info, CONSTANT_Integer_info, CONSTANT_Long_info, CONSTANT_Float_info, CONSTANT_Double_info, CONSTANT_MethodHandle_info, or CONSTANT_MethodType_info structure

CONSTANT_MethodHandle_info The CONSTANT_MethodHandle_info structure is used to represent a method handle

这个BootstrapMethod属性能够告诉invokedynamic指令须要的boostrap method的引用以及参数的数量和类型。
#28对应的是bootstrap_method_ref,为

#28 = MethodHandle       #6:#40         // invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;

按照JVM规范,BootstrapMethod接收3个标准参数和一些自定义参数,标准参数以下

  1. MethodHandles.$Lookup类型的caller参数,这个对象可以经过相似反射的方式拿到在执行invokedynamic指令这个环境下可以调动到的方法,好比其余类的private方法是调用不到的。这个参数由JVM来入栈
  2. String类型的invokedName参数,表示invokedynamic要实现的方法的名字,在这里是apply,是lambda表达式实现的方法名,这个参数由JVM来入栈
  3. MethodType类型的invokedType参数,表示invokedynamic要实现的方法的类型,在这里是()Function,这个参数由JVM来入栈

#29,#30,#31是可选的自定义参数类型

#29 = MethodType         #41            //  (Ljava/lang/Object;)Ljava/lang/Object;
#30 = MethodHandle       #6:#42         // invokestatic com/github/liuzhengyang/invokedyanmic/RunnableTest.lambda$run$0:(Ljava/lang/Integer;)Ljava/lang/Integer;
#31 = MethodType         #21            //  (Ljava/lang/Integer;)Ljava/lang/Integer;

经过java.lang.invoke.LambdaMetafactory#metafactory的代码说明下

public static CallSite metafactory(MethodHandles.Lookup caller,
        String invokedName,
        MethodType invokedType,
        MethodType samMethodType,
        MethodHandle implMethod,
        MethodType instantiatedMethodType)

前面三个介绍过了,剩下几个为
MethodType samMethodType: sam(SingleAbstractMethod)就是#29 = MethodType #41 // (Ljava/lang/Object;)Ljava/lang/Object;,表示要实现的方法对象的类型,不过它没有泛型信息,(Ljava/lang/Object;)Ljava/lang/Object;
MethodHandle implMethod: 真正要执行的方法的位置,这里是com.github.liuzhengyang.invokedyanmic.Runnable.lambda$run$0(Integer)Integer/invokeStatic,这里是javac生成的一个对lambda解语法糖以后的方法,后面进行介绍
MethodType instantiatedMethodType: 和samMethod基本同样,不过会包含泛型信息,(Ljava/lang/Integer;)Ljava/lang/Integer;

private static java.lang.Integer lambda$run$0(java.lang.Integer);这个方法是有javac把lambda表达式desugar解语法糖生成的方法,若是lambda表达式用到了上下文变量,则为有状态的,这个表达式也叫作capturing-lambda,会把变量做为这个生成方法的参数传进来,没有状态则为non-capturing。
另外若是使用的是java8的MethodReference,例如Main::run这种语法则说明有能够直接调用的方法,就不须要再生成一个中间方法。

继续看5: astore_1这条指令,表示把当前操做数栈的对象引用保存到index为1的局部变量表中,即赋值给了function变量。
说明前面执行完invokedynamic #2, 0 后,在操做数栈中插入了一个类型为Function的对象。
这里的过程须要继续看一下LambdaMetafactory#metafactory的实现。

mf = new InnerClassLambdaMetafactory(caller, invokedType,
                                        invokedName, samMethodType,
                                        implMethod, instantiatedMethodType,
                                        false, EMPTY_CLASS_ARRAY, EMPTY_MT_ARRAY);
mf.validateMetafactoryArgs();
return mf.buildCallSite();

建立了一个InnerClassLambdaMetafactory,而后调用buildCallSite返回CallSite

看一下InnerClassLambdaMetafactory是作什么的: Lambda metafactory implementation which dynamically creates an inner-class-like class per lambda callsite.

怎么回事!饶了一大圈仍是建立了一个inner class!先不要慌,先看完,最后分析下和普通inner class的区别。

建立InnerClassLambdaMetafactory的过程大概是参数的一些赋值和初始化等
再看buildCallSite,这个复杂一些,方法描述说明为Build the CallSite. Generate a class file which implements the functional interface, define the class, if there are no parameters create an instance of the class which the CallSite will return, otherwise, generate handles which will call the class' constructor.

建立一个实现functional interface的的class文件,define这个class,若是是没有参数non-capturing类型的建立一个类实例,CallSite能够固定返回这个实例,不然有状态,CallSite每次都要经过构造函数来生成新对象。
这里相比普通的InnerClass,有一个内存优化,无状态就使用一个对象。

方法实现的第一步是调用spinInnerClass(),经过ASM生成一个function interface的实现类字节码而且进行类加载返回。

只保留关键代码
cw.visit(CLASSFILE_VERSION, ACC_SUPER + ACC_FINAL + ACC_SYNTHETIC, lambdaClassName, null, JAVA_LANG_OBJECT, interfaces);
for (int i = 0; i < argDescs.length; i++) {
    FieldVisitor fv = cw.visitField(ACC_PRIVATE + ACC_FINAL, argNames[i], argDescs[i], null, null);
    fv.visitEnd();
}
generateConstructor();
if (invokedType.parameterCount() != 0) {
    generateFactory();
}
// Forward the SAM method
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, samMethodName, samMethodType.toMethodDescriptorString(), null, null);
mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Hidden;", true);
new ForwardingMethodGenerator(mv).generate(samMethodType);

byte[] classBytes = cw.toByteArray();

return UNSAFE.defineAnonymousClass(targetClass, classBytes, null);

生成方法为

  1. 声明要实现的接口
  2. 建立保存参数用的各个字段
  3. 生成构造函数,若是有参数,则生成一个static Factory方法
  4. 实现function interface里的要实现的方法,forward到implMethodName上,也就是javac生成的方法或者MethodReference指向的方法
  5. 生成完毕,经过ClassWrite.toByteArray拿到class字节码数组
  6. 经过UNSAFE.defineAnonymousClass(targetClass, classBytes, null) define这个内部类class。这里的defineAnonymousClass比较特殊,它建立出来的匿名类会挂载到targetClass这个宿主类上,而后能够用宿主类的类加载器加载这个类。可是不会可是并不会放到SystemDirectory里,SystemDirectory是类加载器对象+类名字到kclass地址的映射,没有放到这个Directory里,就能够重复加载了,来方便实现一些动态语言的功能,而且可以防止一些内存泄露状况。

这些比较抽象,直观的看一下生成的结果

// $FF: synthetic class
final class RunnableTest$$Lambda$1 implements Function {
    private RunnableTest$$Lambda$1() {
    }

    @Hidden
    public Object apply(Object var1) {
        return RunnableTest.lambda$run$0((Integer)var1);
    }
}

若是有参数的状况呢,例如从外部类中使用了一个非静态字段,并使用了一个外部局部变量

private int a;
void run() {
    int b = 0;
    Function<Integer, Integer> function = input -> input + 1 + a + b;
    function.apply(1);
}

对应的结果为

final class RunnableTest$$Lambda$1 implements Function {
    private final RunnableTest arg$1;
    private final int arg$2;

    private RunnableTest$$Lambda$1(RunnableTest var1, int var2) {
        this.arg$1 = var1;
        this.arg$2 = var2;
    }

    private static Function get$Lambda(RunnableTest var0, int var1) {
        return new RunnableTest$$Lambda$1(var0, var1);
    }

    @Hidden
    public Object apply(Object var1) {
        return this.arg$1.lambda$run$0(this.arg$2, (Integer)var1);
    }
}

建立完inner class以后,就是生成须要的CallSite了。 若是没有参数,则生成这个inner class的一个function interface对象示例,建立一个固定返回这个对象的MethodHandle,再包装成ConstantCallSite返回。
若是有参数,则返回一个须要每次调用Factory方法产生function interface的对象实例的MethodHandle,包装成ConstantCallSite返回。

这样就完成了bootstrap的过程。invokedynamic连接完以后,后面的调用就直接调用到对应的MethodHandle了,具体是实现就是返回固定的内部类对象,或每次建立新内部类对象。

再次对比经过invokedynamic相对于直接匿名内部类语法糖的优点

咱们再想一下,Java8实现这一套骚操做的缘由是什么。 既然lambda表达式又不须要什么动态分派(调动哪一个方法是明确的), 为何要用invokedynamic呢?
JVM虚拟机的一个基本保证就是低版本的class文件也是可以在高版本的JVM上运行的,而且JVM虚拟机经过版本升级,是在不断优化和提高性能的。

直接转换成内部类实现,当然简单,但编译后的二进制字节码(包括第三方jar包等)内容就固定了,实现固定为建立内部类对象+invoke{virtual, static, special, interface}调用。
将来提高性能只能靠提高建立类对象、invoke指令调用这几个地方的优化。换个熟悉点的说法就是这里写死了。
若是经过invokedynamic呢,javac编译后把足够的信息保留了下来,在JVM执行时可以动态决定如何实现lambda,也就能不断优化lambda表达式的实现,并保持兼容性,给将来留下了更多可能。

总结

本文是我学习lambda的一些总结,介绍了lambda表达式出现的缘由、实现方法以及不一样实现思路上的对比。 对lambda知识也只是略看了一些代码、资料,若有错误或不明确的地方还请你们无情指出。