【修炼内功】[Java8] Lambda究竟是不是匿名类的语法糖

本文已收录【修炼内功】跃迁之路

Lambda究竟是不是匿名类的语法糖

初次接触Java8的时候感觉Lambda表达式很神奇(Lambda表达式带来的编程新思路),但又总感觉它就是匿名类或者内部类的语法糖而已,只是语法上更为简洁罢了,如同以下的代码

public class Lambda {
    private static void hello(String name, Consumer<String> printer) {
        printer.accept(name);
    }

    public static void main(String[] args) {
        hello("lambda", (name) -> System.out.println("Hello " + name));
        hello("匿名类", new Consumer<String> () {
            @Override
            public void accept(String name) {
                System.out.println("Hello " + name);
            }
        });
        hello("内部类", new SupplierImpl());
    }

    static class SupplierImpl implements Consumer<String> {
        @Override
        public void accept(String name) {
            System.out.println("Hello " + name);
        }
    }
}

编译后会产生三个文件

sugar_1

虽然从使用效果来看,Lambda与匿名类或者内部类有相似之处(当然也有很大不同,如this指针等 Lambda表达式里的"陷阱"),但从编译结果来看,并不能简单地将Lambda与匿名类/内部类划等号

简单查看Lambda字节码javap -p Lambda

sugar_2

Java编译器自动帮我们生成了方法lambda$main$0,我们有理由相信,Lambda表达式内的逻辑就封装在此函数内

sugar_3

生成的方法lambda$main$0又是如何被调用的呢?

sugar_4

Lambda的调用使用了invokedynamic指令,虚拟机视角的方法调用一文中已经详细介绍了invokedynamic,但这里还是看不出invokedynamic指令与lambda$main$0方法之间到底是如何关联起来的,invokedynamic指令的启动函数(BootstrapMethod)与调用点(CallSite)又在哪里?

其实仔细查看字节码的话可以发下,编译器还会额外生成一个内部类

sugar_5

仔细查看内部类的逻辑,是不是像极了虚拟机视角的方法调用一文中所提invokedynamic的运行过程

  1. 在第一次执行invokedynamic时,JVM虚拟机会调用该指令所对应的启动方法(BootstrapMethod)来生成调用点
  2. 启动方法(BootstrapMethod)由方法句柄来指定(MH_BootstrapMethod)
  3. 启动方法接受三个固定的参数,分别为 Lookup实例、指代目标方法名的字符串及该调用点能够链接的方法句柄类型
  4. 将调用点绑定至该invokedynamic指令中,之后的运行中虚拟机会直接调用绑定的调用点所链接的方法句柄

为了验证此想法,可以执行java -Djdk.internal.lambda.dumpProxyClasses Lambda用来导出内部类

sugar_6

跟踪内部类的运行可以发现,在执行lambda表达式的时候会调用MethodHandleNatives.linkCallSite方法来生成并链接到调用点

// Up-calls from the JVM.
// These must NOT be public.

/**
  * The JVM is linking an invokedynamic instruction.  Create a reified call site for it.
  */
static MemberName linkCallSite(Object callerObj,
                               Object bootstrapMethodObj,
                               Object nameObj, Object typeObj,
                               Object staticArguments,
                               Object[] appendixResult) {
    MethodHandle bootstrapMethod = (MethodHandle)bootstrapMethodObj;
    Class<?> caller = (Class<?>)callerObj;
    String name = nameObj.toString().intern();
    MethodType type = (MethodType)typeObj;
    if (!TRACE_METHOD_LINKAGE)
        return linkCallSiteImpl(caller, bootstrapMethod, name, type,
                                staticArguments, appendixResult);
    return linkCallSiteTracing(caller, bootstrapMethod, name, type,
                               staticArguments, appendixResult);
}
static MemberName linkCallSiteImpl(Class<?> caller,
                                   MethodHandle bootstrapMethod,
                                   String name, MethodType type,
                                   Object staticArguments,
                                   Object[] appendixResult) {
    CallSite callSite = CallSite.makeSite(bootstrapMethod,
                                          name,
                                          type,
                                          staticArguments,
                                          caller);
    if (callSite instanceof ConstantCallSite) {
        appendixResult[0] = callSite.dynamicInvoker();
        return Invokers.linkToTargetMethod(type);
    } else {
        appendixResult[0] = callSite;
        return Invokers.linkToCallSiteMethod(type);
    }
}

caller调用lambda方法的类Lambda [Class]

bootstrapMethod为启动方法的句柄 [MethodHandler]

name为lambda表达式实际类型中需要执行的方法名acccept (Consumer.accept)

type为生成的方法类型()Consumer [MethodType]

staticArguments中包含了lambda方法的方法句柄 [MethodHandler] 及方法类型 [MethodType]

CallSite.makeSite方法会生成调用点,最终调用如class文件中所示的LambdaMetafactory.metafactory方法

public static CallSite metafactory(MethodHandles.Lookup caller,
                                   String invokedName,
                                   MethodType invokedType,
                                   MethodType samMethodType,
                                   MethodHandle implMethod,
                                   MethodType instantiatedMethodType)
    throws LambdaConversionException {
    AbstractValidatingLambdaMetafactory mf;
    mf = new InnerClassLambdaMetafactory(caller, invokedType,
                                         invokedName, samMethodType,
                                         implMethod, instantiatedMethodType,
                                         false, EMPTY_CLASS_ARRAY, EMPTY_MT_ARRAY);
    mf.validateMetafactoryArgs();
    return mf.buildCallSite();
}

简单来讲,所生成内部类作用,是为了生成调用点,并链接到invokedynamic指令,以便动态调用

如果一个类中,多次使用lambda表达式,会生成多少个方法,又会生成多少个内部类?

public class Lambda {
    private static void hello(String name, Consumer<String> printer) {
        printer.accept(name);
    }

    public static void main(String[] args) {
        hello("lambda1", (name) -> System.out.println("Hello " + name));
        hello("lambda2", (name) -> System.out.println("Hello " + name));
        new Thread(() -> {
            System.out.println("thread");
        }).start();
    }
}

上述示例中共使用了三处、两种(Consumer、Runnable)Lambda表达式,编译后查看class文件

sugar_7

对于每一个lambda表达式,都会生成一个静态的私有方法

再查看内部类

sugar_8

只会生成一个内部类,但存在三个方法,每个方法对应一个lambda私有方法,用以生成对应的调用点绑定到相应的invokedynamic指令上

结合以上我们可以总结出:

  • lambda表达式会被编译为invokedynamic指令
  • 每一个lambda表达式的实现逻辑均会被封装为一个静态私有方法
  • 只要存在lambda表达式调用,便会生成一个内部类
  • 内部类中每一个方法(启动方法 BoostrapMethod)对应一个lambda表达式所生成的静态私有方法,内部类中的方法用以生成对应的调用点绑定到相应的invokedynamic指令上

这也解释了为什么lambda中的this指针指向的是周围的类 (定义该Lambda表达式时所处的类) (Lambda表达式里的"陷阱")

所以,lambda表达式确实是语法糖,但并不是匿名类/内部类的语法糖


订阅号

阅读 8.7k

推荐阅读
林中小舍
用户专栏

工作中的坑点及经验

51 人关注
41 篇文章
专栏主页