当前位置: 开发笔记 > 前端 > 正文

Java8动态类型语言Lambda表达式实现原理解析

作者：yuanchengyc | 来源：互联网 | 2022-01-13 09:46

Java8支持动态语言，看到了很酷的Lambda表达式，对一直以静态类型语言自居的Java，让人看到了Java虚拟机可以支持动态语言的目标。接下来通过本文给大家介绍Java8动态类型语言Lambda表达式实现原理分析,需要的朋友可以参考下

Java 8支持动态语言，看到了很酷的Lambda表达式，对一直以静态类型语言自居的Java，让人看到了Java虚拟机可以支持动态语言的目标。

import java.util.function.Consumer; 
public class Lambda { 
  public static void main(String[] args) { 
    Consumer c = s -> System.out.println(s); 
    c.accept("hello lambda!"); 
  } 
}

刚看到这个表达式，感觉java的处理方式是属于内部匿名类的方式

public class Lambda { 
  static { 
    System.setProperty("jdk.internal.lambda.dumpProxyClasses", "."); 
  } 
  public static void main(String[] args) { 
    Consumer c = new Consumer(){ 
      @Override 
      public void accept(String s) { 
        System.out.println(s); 
      } 
      }; 
    c.accept("hello lambda"); 
  } 
}

编译的结果应该是Lambda.class , Lambda$1.class 猜测在支持动态语言java换汤不换药，在最后编译的时候生成我们常见的方式。

但是结果不是这样的，只是产生了一个Lambda.class

反编译吧，来看看真相是什么？

javap -v -p Lambda.class

注意 -p 这个参数 -p 参数会显示所有的方法，而不带默认是不会反编译private 的方法的

public Lambda(); 
  descriptor: ()V 
  flags: ACC_PUBLIC 
  Code: 
   stack=1, locals=1, args_size=1 
     0: aload_0 
     1: invokespecial #21         // Method java/lang/Object."":()V 
     4: return 
   LineNumberTable: 
    line 3: 0 
   LocalVariableTable: 
    Start Length Slot Name  Signature 
      0    5   0 this  LLambda; 
 public static void main(java.lang.String[]); 
  descriptor: ([Ljava/lang/String;)V 
  flags: ACC_PUBLIC, ACC_STATIC 
  Code: 
   stack=2, locals=2, args_size=1 
     0: invokedynamic #30, 0       // InvokeDynamic #0:accept:()Ljava/util/function/Consumer; 
     5: astore_1 
     6: aload_1 
     7: ldc      #31         // String hello lambda 
     9: invokeinterface #33, 2      // InterfaceMethod java/util/function/Consumer.accept:(Ljava/lang/Object;)V 
    14: return 
   LineNumberTable: 
    line 8: 0 
    line 9: 6 
    line 10: 14 
   LocalVariableTable: 
    Start Length Slot Name  Signature 
      0   15   0 args  [Ljava/lang/String; 
      6    9   1   c  Ljava/util/function/Consumer; 
   LocalVariableTypeTable: 
    Start Length Slot Name  Signature 
      6    9   1   c  Ljava/util/function/Consumer; 
 private static void lambda$0(java.lang.String); 
  descriptor: (Ljava/lang/String;)V 
  flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC 
  Code: 
   stack=2, locals=1, args_size=1 
     0: getstatic   #46         // Field java/lang/System.out:Ljava/io/PrintStream; 
     3: aload_0 
     4: invokevirtual #50         // Method java/io/PrintStream.println:(Ljava/lang/String;)V 
     7: return 
   LineNumberTable: 
    line 8: 0 
   LocalVariableTable: 
    Start Length Slot Name  Signature 
      0    8   0   s  Ljava/lang/String; 
} 
SourceFile: "Lambda.java" 
BootstrapMethods: 
 0: #66 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: 
   #67 (Ljava/lang/Object;)V 
   #70 invokestatic Lambda.lambda$0:(Ljava/lang/String;)V 
   #71 (Ljava/lang/String;)V 
InnerClasses: 
   public static final #77= #73 of #75; //Lookup=class java/lang/invoke/MethodHandles$Lookup of class java/lang/invoke/MethodHandles

在这里我们发现了几个与我们常见的java不太一样的地方，由于常量定义太多了，文章中就不贴出了

1. Invokedynamic 指令

Java的调用函数的四大指令（invokevirtual、invokespecial、invokestatic、invokeinterface)，通常方法的符号引用在静态类型语言编译时就能产生，而动态类型语言只有在运行期才能确定接收者类型，改变四大指令的语意对java的版本有很大的影响，所以在JSR 292 《Supporting Dynamically Typed Languages on the Java Platform》添加了一个新的指令

Invokedynamic

0: invokedynamic #30, 0 // InvokeDynamic #0:accept:()Ljava/util/function/Consumer;

#30 是代表常量#30 也就是后面的注释InvokeDynamic #0:accept:()Ljava/util/function/Consumer;

0 是占位符号，目前无用

2. BootstrapMethods

每一个invokedynamic指令的实例叫做一个动态调用点(dynamic call site), 动态调用点最开始是未链接状态(unlinked:表示还未指定该调用点要调用的方法), 动态调用点依靠引导方法来链接到具体的方法. 引导方法是由编译器生成, 在运行期当JVM第一次遇到invokedynamic指令时, 会调用引导方法来将invokedynamic指令所指定的名字(方法名,方法签名)和具体的执行代码(目标方法)链接起来, 引导方法的返回值永久的决定了调用点的行为.引导方法的返回值类型是java.lang.invoke.CallSite, 一个invokedynamic指令关联一个CallSite, 将所有的调用委托到CallSite当前的target(MethodHandle)
InvokeDynamic #0 就是BootstrapMethods表示#0的位置

0: #66 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: 
  #67 (Ljava/lang/Object;)V 
  #70 invokestatic Lambda.lambda$0:(Ljava/lang/String;)V 
  #71 (Ljava/lang/String;)V

我们看到调用了LambdaMetaFactory.metafactory 的方法

参数:

LambdaMetafactory.metafactory(Lookup, String, MethodType, MethodType, MethodHandle, MethodType)有六个参数, 按顺序描述如下

1. MethodHandles.Lookup caller : 代表查找上下文与调用者的访问权限, 使用invokedynamic指令时, JVM会自动自动填充这个参数

2. String invokedName : 要实现的方法的名字, 使用invokedynamic时, JVM自动帮我们填充(填充内容来自常量池InvokeDynamic.NameAndType.Name), 在这里JVM为我们填充为 "apply", 即Consumer.accept方法名.

3. MethodType invokedType : 调用点期望的方法参数的类型和返回值的类型(方法signature). 使用invokedynamic指令时, JVM会自动自动填充这个参数(填充内容来自常量池InvokeDynamic.NameAndType.Type), 在这里参数为String, 返回值类型为Consumer, 表示这个调用点的目标方法的参数为String, 然后invokedynamic执行完后会返回一个即Consumer实例.

4. MethodType samMethodType : 函数对象将要实现的接口方法类型, 这里运行时, 值为 (Object)Object 即 Consumer.accept方法的类型(泛型信息被擦除).#67 (Ljava/lang/Object;)V

5. MethodHandle implMethod : 一个直接方法句柄(DirectMethodHandle), 描述在调用时将被执行的具体实现方法 (包含适当的参数适配, 返回类型适配, 和在调用参数前附加上捕获的参数), 在这里为 #70 invokestatic Lambda.lambda$0:(Ljava/lang/String;)V 方法的方法句柄.

6. MethodType instantiatedMethodType : 函数接口方法替换泛型为具体类型后的方法类型, 通常和 samMethodType 一样, 不同的情况为泛型:

比如函数接口方法定义为 void accept(T t) T为泛型标识, 这个时候方法类型为(Object)Void, 在编译时T已确定, 即T由String替换, 这时samMethodType就是 (Object)Void, 而instantiatedMethodType为(String)Void.

第4, 5, 6 三个参数来自class文件中的. 如上面引导方法字节码中Method arguments后面的三个参数就是将应用于4, 5, 6的参数.

Method arguments: 
  #67 (Ljava/lang/Object;)V 
  #70 invokestatic Lambda.lambda$0:(Ljava/lang/String;)V 
  #71 (Ljava/lang/String;)V

我们来看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(); 
  }

在buildCallSite的函数中

CallSite buildCallSite() throws LambdaConversionException { 
    final Class<&＃63;> innerClass = spinInnerClass();

函数spinInnerClass 构建了这个内部类，也就是生成了一个Lambda$$Lambda$1/716157500 这样的内部类,这个类是在运行的时候构建的，并不会保存在磁盘中，如果想看到这个构建的类，可以通过设置环境参数

System.setProperty("jdk.internal.lambda.dumpProxyClasses", ".");

会在你指定的路径 . 当前运行路径上生成这个内部类

3.静态类

Java在编译表达式的时候会生成lambda$0静态私有类，在这个类里实现了表达式中的方法块 system.out.println(s);

private static void lambda$0(java.lang.String); 
  descriptor: (Ljava/lang/String;)V 
  flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC 
  Code: 
   stack=2, locals=1, args_size=1 
     0: getstatic   #46         // Field java/lang/System.out:Ljava/io/PrintStream; 
     3: aload_0 
     4: invokevirtual #50         // Method java/io/PrintStream.println:(Ljava/lang/String;)V 
     7: return 
   LineNumberTable: 
    line 8: 0 
   LocalVariableTable: 
    Start Length Slot Name  Signature 
      0    8   0   s  Ljava/lang/String;

当然了在上一步通过设置的jdk.internal.lambda.dumpProxyClasses里生成的Lambda$$Lambda$1.class

public void accept(java.lang.Object); 
  descriptor: (Ljava/lang/Object;)V 
  flags: ACC_PUBLIC 
  Code: 
   stack=1, locals=2, args_size=2 
    0: aload_1 
    1: checkcast   #15         // class java/lang/String 
    4: invokestatic #21         // Method Lambda.lambda$0:(Ljava/lang/String;)V 
    7: return 
  RuntimeVisibleAnnotations: 
   0: #13()

调用了Lambda.lambda$0静态函数，也就是表达式中的函数块

总结

这样就完成的实现了Lambda表达式，使用invokedynamic指令，运行时调用LambdaMetafactory.metafactory动态的生成内部类，实现了接口，内部类里的调用方法块并不是动态生成的，只是在原class里已经编译生成了一个静态的方法，内部类只需要调用该静态方法

以上所述是小编给大家介绍的Java 8 动态类型语言Lambda表达式实现原理解析，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对网站的支持！

bootstrap

推荐阅读

js
深入理解ExtJS：从入门到精通

本文详细介绍了ExtJS的功能及其在大型企业前端开发中的应用。通过实例和详细的文件结构解析，帮助初学者快速掌握ExtJS的核心概念，并提供实用技巧和最佳实践。 ... [详细]

蜡笔小新 2024-12-21 15:41:04
js
精选设计感强的网站模板推荐

本文汇集了一系列具有强烈设计感的网站模板，特别是来自知名平台WrapBootstrap的响应式网站模板。这些模板不仅美观，而且功能强大，适合各种类型的网站建设需求。 ... [详细]

蜡笔小新 2024-12-20 20:50:19
js
Kafka Topic 数据管理与清理策略

本文探讨了在生产环境中如何有效管理和定期清理Kafka Topic中的数据。介绍了基于时间、日志大小和日志起始偏移量三种清除方式，并重点讲解了基于时间的清除策略及其配置方法。 ... [详细]

蜡笔小新 2024-12-15 13:50:22
js
Spring Cloud Config 配置中心请求路径未生效问题解决

在使用 Spring Cloud Config 作为配置中心时，若在配置文件中指定了请求路径但未能生效，本文将探讨其原因及解决方案。 ... [详细]

蜡笔小新 2024-12-15 13:22:47
js
修复(Datepicker)：初始为空时输入验证器未被调用

修复了Datepicker组件中，当字段值默认为null时，输入验证器直到选择日期后才被调用的问题。 ... [详细]

蜡笔小新 2024-12-15 10:40:38
js
前端常用的布局类型——前端布局

1.Static静态布局固定宽高：2.Liquid流式布局宽高用百分比，按屏幕分辨率调整，布局不发生变化3.Adaptive自适应 ... [详细]

蜡笔小新 2024-12-14 10:35:02
js
PHP中静态类与静态变量的应用差异探讨

本文深入探讨了PHP编程语言中静态类与静态变量的具体应用及其差异性，旨在帮助开发者更好地理解和运用这些概念，以提升代码质量和效率。 ... [详细]

蜡笔小新 2024-12-13 16:35:20
npm
Web前端开发中Webpack项目的实用技巧总结

本文探讨了在使用Webpack构建前端项目时的一些实用技巧，包括如何高效地使用移动端UI框架Mint UI和MUI，以及如何优化项目性能和用户体验。 ... [详细]

蜡笔小新 2024-12-13 16:21:04
npm
如何解决PHP中时间获取不准确的问题

本文探讨了在PHP开发过程中遇到的时间获取错误问题，并提供了详细的解决方案，包括通过修改配置文件和编程方法来调整时区设置。 ... [详细]

蜡笔小新 2024-12-13 15:33:22
npm
Consul 单节点与集群环境构建指南

本文详细介绍了如何安装和配置 Consul 以支持服务注册与发现、健康检查等功能，包括单节点和集群环境的搭建步骤。 ... [详细]

蜡笔小新 2024-12-13 09:10:57
js
使用Bootstrap创建响应式渐变固定头部导航栏的方法

本文详细介绍了如何利用Bootstrap框架构建一个具有渐变效果的固定顶部响应式导航栏，包括HTML结构、CSS样式以及JavaScript交互的完整实现过程。适合前端开发者和学习者参考。 ... [详细]

蜡笔小新 2024-12-12 18:04:25
js
深入理解Java类加载机制

本文详细探讨了Java虚拟机（JVM）中类加载器的工作原理，特别是如何通过类的全限定名从外部源获取二进制字节流，以及不同类型的类加载器及其在双亲委派模型中的角色。 ... [详细]

蜡笔小新 2024-12-12 13:15:46
js
深入解析JVM：类加载子系统详解

本文旨在深入探讨Java虚拟机（JVM）中的类加载子系统，包括其基本结构、类加载器的工作原理、类的加载过程以及双亲委派机制。通过对这些关键点的详细分析，帮助读者更好地理解和掌握JVM的核心机制。 ... [详细]

蜡笔小新 2024-12-12 12:59:12
js
在Angular CLI项目中集成Bootstrap

本文介绍了如何在Angular CLI创建的项目中安装并配置Bootstrap，包括必要的依赖项jQuery和Popper.js的安装步骤。 ... [详细]

蜡笔小新 2024-12-11 16:29:15
js
PHP 中服务器变量的配置指南

本文详细介绍了在 PHP 环境下如何正确设置服务器变量的方法，包括变量类型的动态转换及其应用场景。适合初学者及进阶开发者阅读。 ... [详细]

蜡笔小新 2024-12-09 21:25:00

yuanchengyc

这个家伙很懒，什么也没留下！

Tags | 热门标签

RankList | 热门文章